cleanup for FastTIMES

akvo/gui/addCircularLoop.ui

     <x>0</x>
     <y>0</y>
     <width>400</width>
-    <height>395</height>
+    <height>438</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Dialog</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
+   <item row="2" column="2">
+    <widget class="QDoubleSpinBox" name="loopHeight">
+     <property name="toolTip">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Akvo uses a positive down convention, a slight negative value to the loop height improves numerical stability using digital filtering hankel transforms. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+     <property name="decimals">
+      <number>3</number>
+     </property>
+     <property name="minimum">
+      <double>-99.000000000000000</double>
+     </property>
+     <property name="value">
+      <double>-0.001000000000000</double>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="2">
+    <widget class="QDoubleSpinBox" name="centreEast">
+     <property name="minimum">
+      <double>-99999999.000000000000000</double>
+     </property>
+     <property name="maximum">
+      <double>99999999.989999994635582</double>
+     </property>
+    </widget>
+   </item>
    <item row="2" column="0">
     <widget class="QLabel" name="label_3">
      <property name="text">
      </property>
     </widget>
    </item>
-   <item row="6" column="2">
+   <item row="7" column="2">
     <widget class="QDoubleSpinBox" name="dip">
      <property name="enabled">
       <bool>false</bool>
      </property>
     </widget>
    </item>
-   <item row="7" column="0">
-    <widget class="QLabel" name="label_8">
-     <property name="text">
-      <string>azimuth (°)</string>
+   <item row="5" column="2">
+    <widget class="QSpinBox" name="loopTurns">
+     <property name="minimum">
+      <number>1</number>
+     </property>
+     <property name="maximum">
+      <number>100000</number>
      </property>
     </widget>
    </item>
-   <item row="0" column="0">
-    <widget class="QLabel" name="label">
+   <item row="11" column="2">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="0">
+    <widget class="QLabel" name="label_6">
      <property name="text">
-      <string>centre northing (m)</string>
+      <string>turns</string>
      </property>
     </widget>
    </item>
      </property>
     </widget>
    </item>
-   <item row="6" column="0">
-    <widget class="QLabel" name="label_7">
-     <property name="text">
-      <string>dip (°)</string>
+   <item row="6" column="2">
+    <widget class="QSpinBox" name="segments">
+     <property name="toolTip">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Currently Akvo/Merlin calculates circular loops using segments of wire, forming a polygon. Analytic circular loops may be added in the future. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
-    </widget>
-   </item>
-   <item row="10" column="2">
-    <widget class="QDialogButtonBox" name="buttonBox">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
+     <property name="minimum">
+      <number>5</number>
      </property>
-     <property name="standardButtons">
-      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     <property name="maximum">
+      <number>200</number>
+     </property>
+     <property name="value">
+      <number>15</number>
      </property>
     </widget>
    </item>
      </property>
     </widget>
    </item>
-   <item row="2" column="2">
-    <widget class="QDoubleSpinBox" name="loopHeight">
-     <property name="toolTip">
-      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Akvo uses a positive down convention, a slight negative value to the loop height improves numerical stability using digital filtering hankel transforms. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-     </property>
-     <property name="decimals">
-      <number>3</number>
-     </property>
-     <property name="minimum">
-      <double>-99.000000000000000</double>
+   <item row="7" column="0">
+    <widget class="QLabel" name="label_7">
+     <property name="text">
+      <string>dip (°)</string>
      </property>
-     <property name="value">
-      <double>-0.001000000000000</double>
+    </widget>
+   </item>
+   <item row="3" column="0">
+    <widget class="QLabel" name="label_4">
+     <property name="text">
+      <string>radius (m)</string>
      </property>
     </widget>
    </item>
-   <item row="1" column="0">
-    <widget class="QLabel" name="label_2">
+   <item row="8" column="0">
+    <widget class="QLabel" name="label_8">
      <property name="text">
-      <string>centre easting (m)</string>
+      <string>azimuth (°)</string>
      </property>
     </widget>
    </item>
-   <item row="7" column="2">
+   <item row="8" column="2">
     <widget class="QDoubleSpinBox" name="az">
      <property name="enabled">
       <bool>false</bool>
      </property>
     </widget>
    </item>
-   <item row="3" column="0">
-    <widget class="QLabel" name="label_4">
+   <item row="1" column="0">
+    <widget class="QLabel" name="label_2">
      <property name="text">
-      <string>radius (m)</string>
+      <string>centre easting (m)</string>
      </property>
     </widget>
    </item>
-   <item row="4" column="0">
-    <widget class="QLabel" name="label_6">
+   <item row="0" column="0">
+    <widget class="QLabel" name="label">
      <property name="text">
-      <string>turns</string>
-     </property>
-    </widget>
-   </item>
-   <item row="1" column="2">
-    <widget class="QDoubleSpinBox" name="centreEast">
-     <property name="minimum">
-      <double>-99999999.000000000000000</double>
-     </property>
-     <property name="maximum">
-      <double>99999999.989999994635582</double>
+      <string>centre northing (m)</string>
      </property>
     </widget>
    </item>
-   <item row="5" column="0">
+   <item row="6" column="0">
     <widget class="QLabel" name="label_5">
      <property name="text">
       <string>segments</string>
      </property>
     </widget>
    </item>
-   <item row="4" column="2">
-    <widget class="QSpinBox" name="loopTurns">
-     <property name="minimum">
-      <number>1</number>
-     </property>
-     <property name="maximum">
-      <number>100000</number>
+   <item row="4" column="0">
+    <widget class="QLabel" name="label_9">
+     <property name="text">
+      <string>current flow</string>
      </property>
     </widget>
    </item>
-   <item row="5" column="2">
-    <widget class="QSpinBox" name="segments">
-     <property name="toolTip">
-      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Currently Akvo/Merlin calculates circular loops using segments of wire, forming a polygon. Analytic circular loops may be added in the future. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-     </property>
-     <property name="minimum">
-      <number>5</number>
-     </property>
+   <item row="4" column="2">
+    <widget class="QComboBox" name="cwiseBox">
+     <item>
+      <property name="text">
+       <string>clockwise</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>anti-clockwise</string>
+      </property>
+     </item>
     </widget>
    </item>
   </layout>

akvo/gui/addFigure8Loop.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>figure8LoopAdd</class>
+ <widget class="QDialog" name="figure8LoopAdd">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>456</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="12" column="2">
+    <widget class="QDoubleSpinBox" name="doubleSpinBox_3"/>
+   </item>
+   <item row="7" column="0">
+    <widget class="QLabel" name="label_8">
+     <property name="text">
+      <string>centre easting 2 (m)</string>
+     </property>
+    </widget>
+   </item>
+   <item row="14" column="2">
+    <widget class="QSpinBox" name="segments">
+     <property name="toolTip">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Currently Akvo/Merlin calculates circular loops using segments of wire, forming a polygon. Analytic circular loops may be added in the future. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+     <property name="minimum">
+      <number>5</number>
+     </property>
+     <property name="maximum">
+      <number>200</number>
+     </property>
+     <property name="value">
+      <number>15</number>
+     </property>
+    </widget>
+   </item>
+   <item row="10" column="2">
+    <widget class="QDoubleSpinBox" name="loopHeight">
+     <property name="toolTip">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Akvo uses a positive down convention, a slight negative value to the loop height improves numerical stability using digital filtering hankel transforms. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+     <property name="decimals">
+      <number>3</number>
+     </property>
+     <property name="minimum">
+      <double>-99.000000000000000</double>
+     </property>
+     <property name="value">
+      <double>-0.001000000000000</double>
+     </property>
+    </widget>
+   </item>
+   <item row="13" column="0">
+    <widget class="QLabel" name="label_6">
+     <property name="text">
+      <string>turns</string>
+     </property>
+    </widget>
+   </item>
+   <item row="6" column="2">
+    <widget class="QDoubleSpinBox" name="centreNorth2"/>
+   </item>
+   <item row="8" column="1">
+    <widget class="Line" name="line_4">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="0">
+    <widget class="Line" name="line">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="2">
+    <widget class="QDoubleSpinBox" name="centreEast1">
+     <property name="minimum">
+      <double>-99999999.000000000000000</double>
+     </property>
+     <property name="maximum">
+      <double>99999999.989999994635582</double>
+     </property>
+    </widget>
+   </item>
+   <item row="12" column="0">
+    <widget class="QLabel" name="label_9">
+     <property name="text">
+      <string>TextLabel</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0">
+    <widget class="QLabel" name="label_2">
+     <property name="text">
+      <string>centre easting 1 (m)</string>
+     </property>
+    </widget>
+   </item>
+   <item row="8" column="2">
+    <widget class="Line" name="line_3">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0">
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>centre northing 1 (m)</string>
+     </property>
+    </widget>
+   </item>
+   <item row="6" column="0">
+    <widget class="QLabel" name="label_7">
+     <property name="text">
+      <string>centre northing 2 (m)</string>
+     </property>
+    </widget>
+   </item>
+   <item row="14" column="0">
+    <widget class="QLabel" name="label_5">
+     <property name="text">
+      <string>segments</string>
+     </property>
+    </widget>
+   </item>
+   <item row="17" column="2">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="2">
+    <widget class="Line" name="line_2">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+    </widget>
+   </item>
+   <item row="7" column="2">
+    <widget class="QDoubleSpinBox" name="centreEast2"/>
+   </item>
+   <item row="10" column="0">
+    <widget class="QLabel" name="label_3">
+     <property name="text">
+      <string>height (m)</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="2">
+    <widget class="QDoubleSpinBox" name="centreNorth1">
+     <property name="minimum">
+      <double>-999999999.000000000000000</double>
+     </property>
+     <property name="maximum">
+      <double>9999999999.000000000000000</double>
+     </property>
+    </widget>
+   </item>
+   <item row="13" column="2">
+    <widget class="QSpinBox" name="loopTurns">
+     <property name="minimum">
+      <number>1</number>
+     </property>
+     <property name="maximum">
+      <number>100000</number>
+     </property>
+    </widget>
+   </item>
+   <item row="8" column="0">
+    <widget class="Line" name="line_5">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+    </widget>
+   </item>
+   <item row="9" column="0">
+    <widget class="QLabel" name="label_4">
+     <property name="text">
+      <string>radius  (m)</string>
+     </property>
+    </widget>
+   </item>
+   <item row="9" column="2">
+    <widget class="QDoubleSpinBox" name="loopRadius">
+     <property name="toolTip">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Radius of the loop&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+     <property name="minimum">
+      <double>0.100000000000000</double>
+     </property>
+     <property name="maximum">
+      <double>600.000000000000000</double>
+     </property>
+     <property name="value">
+      <double>50.000000000000000</double>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>figure8LoopAdd</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>figure8LoopAdd</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

akvo/gui/akvoGUI.py

 #/usr/bin/env python 
 import sys
-#import readline
-try: 
-    from akvo.gui.main_ui import Ui_MainWindow
-    uicerr = False
-except: # Fallback 
-    from akvo.gui.mainui import Ui_MainWindow
-    uicerr = """
-USING THE DEFAULT GUI FILES, AKVO MAY NOT WORK CORRECTLY!
-
-See INSTALL.txt for details regarding GUI configuration 
-if you are encountering problems.     
-
-Clicking ignore will prevent this warning from showing 
-each time you launch Akvo.                  
-"""
-
-from akvo.gui.addCircularLoop_ui import Ui_circularLoopAdd
 
 import matplotlib
 matplotlib.use("QT5Agg")
-from PyQt5 import QtCore, QtGui, QtWidgets
-
+from PyQt5 import QtCore, QtGui, QtWidgets #, uic
 import numpy as np
 import time
 import os
 from copy import deepcopy
 from matplotlib.backends.backend_qt4 import NavigationToolbar2QT #as NavigationToolbar
 import datetime, time
+import pkg_resources  # part of setuptools
+from collections import OrderedDict
+from ruamel import yaml
 
+from akvo.gui.main_ui import Ui_MainWindow
+from akvo.gui.addCircularLoop_ui import Ui_circularLoopAdd
+from akvo.gui.addFigure8Loop_ui import Ui_figure8LoopAdd
 from akvo.tressel import mrsurvey 
 
 from pyLemma import LemmaCore  
 from pyLemma import FDEM1D 
 from pyLemma import Merlin
 
-import pkg_resources  # part of setuptools
-version = pkg_resources.require("Akvo")[0].version
+VERSION = pkg_resources.require("Akvo")[0].version
 
-from collections import OrderedDict
-
-from ruamel import yaml
-#import ruamel.yaml 
-#yaml = ruamel.yaml.YAML()
-#yaml.indent(mapping=4)
-
-#import yaml
 # Writes out numpy arrays into Eigen vectors as serialized by Lemma
 class MatrixXr(yaml.YAMLObject):
     yaml_tag = u'MatrixXr'
 class AkvoYamlNode(yaml.YAMLObject):
     yaml_tag = u'AkvoData'
     def __init__(self):
-        self.Akvo_VERSION = version
+        self.Akvo_VERSION = VERSION
         self.Import = OrderedDict() # {}
         self.Processing = [] # OrderedDict() 
         self.Stacking = OrderedDict()
         self.META = OrderedDict() 
-    #def __init__(self, node):
-    #    self.Akvo_VERSION = node["version"]
-    #    self.Import = OrderedDict( node["Import"] ) # {}
-    #    self.Processing = OrderedDict( node["Processing"] ) 
     def __repr__(self):
         return "%s(name=%r, Akvo_VERSION=%r, Import=%r, Processing=%r, self.Stacking=%r, self.META=%r)" % (
             self.__class__.__name__, self.Akvo_VERSION, self.Import, self.Processing, self.Stacking, self.META )
-            #self.__class__.__name__, self.Akvo_VERSION, self.Import, OrderedDict(self.Processing) ) 
     
 try:    
     import thread 
     
     def __init__(self):
         
-        QtWidgets.QMainWindow.__init__(self)
-        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)       
- 
-        akvohome = os.path.expanduser("~") + "/.akvo"
-        if not os.path.exists(akvohome):
-            os.makedirs(akvohome)
+        super().__init__() 
+        #QtWidgets.QMainWindow.__init__(self)
+        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)      
+
+        # alternative to calling pyuic 
+        #self.ui = uic.loadUi('main.ui', self) 
 
         self.ui = Ui_MainWindow()
         self.ui.setupUi(self)
-
-        if uicerr != False and not os.path.exists(akvohome+"/pyuic-warned"):
-            reply = QtGui.QMessageBox.warning(self, 'Warning', uicerr, QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ignore) 
-            if reply == 1024:      # "0x400" in hex
-                pass
-            elif reply == 1048576: # "0x100000" in hex
-                warn = open( akvohome+"/pyuic-warned" ,"w" )
-                warn.write("Gui files were not compiled locally using pyuic! Further warnings have been supressed")
-                warn.close()
+    
         self.RAWDataProc = None 
-
         self.YamlNode = AkvoYamlNode()           
  
         # initialise some stuff
         ###########
         # Buttons #
         ###########
-#         #QtCore.QObject.connect(self.ui.fullWorkflowPushButton, QtCore.SIGNAL("clicked()"), self.preprocess )
         self.ui.loadDataPushButton.pressed.connect(self.loadRAW) 
         self.ui.sumDataGO.pressed.connect( self.sumDataChans )
         self.ui.bandPassGO.pressed.connect( self.bandPassFilter )
         self.ui.fdDesignPushButton.pressed.connect( self.designFDFilter )
         self.ui.downSampleGO.pressed.connect( self.downsample )
         self.ui.windowFilterGO.pressed.connect( self.windowFilter )
-#        self.ui.despikeGO.pressed.connect( self.despikeFilter ) # use smart stack instead 
         self.ui.adaptGO.pressed.connect( self.adaptFilter )
         self.ui.adaptFDGO.pressed.connect( self.adaptFilterFD )
         self.ui.qdGO.pressed.connect( self.quadDet )
         self.ui.dateEdit.dateChanged.connect( self.logSite )
         # this may call the yaml stuff too often... 
         self.ui.txtComments.textChanged.connect( self.logSite )
-        
         self.ui.plotLoops.pressed.connect( self.plotLoops2 )       
+        self.ui.removeLoopButton.pressed.connect( self.removeLoop )       
  
         # Loops
         self.ui.addLoopButton.pressed.connect( self.loopAdd )
             Error.setDetailedText("Each loop label must be unique and comprise at least one character. Leading and trailing whitespace will be trimmed.")
             Error.exec_()
         else:
+            
+            ### Circular loop
             if self.ui.loopGeom.currentText() == "Circular":
                 dialog = QtWidgets.QDialog()
                 dialog.ui = Ui_circularLoopAdd()
                 dialog.ui.setupUi(dialog)
                 dialog.exec_()
                 dialog.show()
+
                 if dialog.result():
                     cn = dialog.ui.centreNorth.value()
                     ce = dialog.ui.centreEast.value()
                     rad = dialog.ui.loopRadius.value()
                     turns = dialog.ui.loopTurns.value()
                     ns = dialog.ui.segments.value()
-                    #print("dip", dialog.ui.dip.value())
-                    #print("azimuth", dialog.ui.az.value())
+                    cwise = dialog.ui.cwiseBox.currentIndex()
+                    print("cwise", cwise)
+                    #dip = dialog.ui.dip.value()
+                    #azimuth = dialog.ui.az.value()
                     
                     self.loops[self.ui.loopLabel.text()] = FDEM1D.PolygonalWireAntenna()
                     self.loops[self.ui.loopLabel.text()].SetNumberOfPoints( dialog.ui.segments.value() + 1 )
 
                     points = np.linspace(0, 2*np.pi, dialog.ui.segments.value()+1)
                     for iseg, ipt in enumerate(points):
-                        #self.loops[self.ui.loopLabel.text()].SetPoint(iseg,( dialog.ui.centreNorth.value(),  dialog.ui.centreEast.value(), dialog.ui.loopHeight.value()))
-                        self.loops[self.ui.loopLabel.text()].SetPoint(iseg, ( cn+rad*np.sin(ipt), ce+rad*np.cos(ipt), ht ))
-                        #self.loops[self.ui.loopLabel.text()].SetPoint(1,(150,  50, -1e-3))
-                    
+                        if cwise == 0:
+                            self.loops[self.ui.loopLabel.text()].SetPoint(iseg, (  cn+rad*np.sin(ipt), ce+rad*np.cos(ipt), ht) )
+                        else:
+                            self.loops[self.ui.loopLabel.text()].SetPoint(iseg, ( -cn+rad*np.sin(ipt), ce+rad*np.cos(ipt), ht) )
                     self.loops[self.ui.loopLabel.text()].SetNumberOfFrequencies(1)
-                    #self.loops[self.ui.loopLabel.text].SetFrequency(0,2246) 
                     self.loops[self.ui.loopLabel.text()].SetCurrent(1.)
-                   
-                    # update the table 
-                    self.ui.txRxTable.setRowCount( len(self.loops.keys()) )
+            
+            if self.ui.loopGeom.currentText() == "figure-8":
+                dialog = QtWidgets.QDialog()
+                dialog.ui = Ui_figure8LoopAdd()
+                dialog.ui.setupUi(dialog)
+                dialog.exec_()
+                dialog.show()
+                
+                if dialog.result():
+                    cn1 = dialog.ui.centreNorth1.value()
+                    ce1 = dialog.ui.centreEast1.value()
+                    cn2 = dialog.ui.centreNorth2.value()
+                    ce2 = dialog.ui.centreEast2.value()
+                    ht = dialog.ui.loopHeight.value()
+                    rad = dialog.ui.loopRadius.value()
+                    turns = dialog.ui.loopTurns.value()
+                    ns = dialog.ui.segments.value()
+                    #cwise = dialog.ui.cwiseBox.currentIndex()
+                    print(cn1, ce1, cn2, ce2, ht, rad, turns, ns)   
+ 
+            # general across all types   
+            if dialog.result():
+                # update the table 
+                self.ui.txRxTable.setRowCount( len(self.loops.keys()) )
                     
-                    pCell = QtWidgets.QTableWidgetItem()
-                    pCell.setText( self.ui.loopLabel.text() ) 
-                    pCell.setFlags( QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled )
-                    self.ui.txRxTable.setItem( len(self.loops.keys())-1, 0, pCell)
+                pCell = QtWidgets.QTableWidgetItem()
+                pCell.setText( self.ui.loopLabel.text() ) 
+                pCell.setFlags( QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled )
+                self.ui.txRxTable.setItem( len(self.loops.keys())-1, 0, pCell)
                     
-                    gCell = QtWidgets.QTableWidgetItem()
-                    gCell.setText( self.ui.loopGeom.currentText() ) 
-                    gCell.setFlags( QtCore.Qt.ItemIsEnabled )
-                    self.ui.txRxTable.setItem( len(self.loops.keys())-1, 1, gCell)
+                gCell = QtWidgets.QTableWidgetItem()
+                gCell.setText( self.ui.loopGeom.currentText() ) 
+                gCell.setFlags( QtCore.Qt.ItemIsEnabled )
+                self.ui.txRxTable.setItem( len(self.loops.keys())-1, 1, gCell)
                     
-                    tCell = QtWidgets.QTableWidgetItem()
-                    tCell.setText( str(dialog.ui.loopTurns.value()) ) 
-                    tCell.setFlags( QtCore.Qt.ItemIsEnabled )
-                    self.ui.txRxTable.setItem( len(self.loops.keys())-1, 2, tCell)
+                tCell = QtWidgets.QTableWidgetItem()
+                tCell.setText( str(dialog.ui.loopTurns.value()) ) 
+                tCell.setFlags( QtCore.Qt.ItemIsEnabled )
+                self.ui.txRxTable.setItem( len(self.loops.keys())-1, 2, tCell)
                     
-                    txCell = QtWidgets.QTableWidgetItem()
-                    txCell.setText( str(self.ui.loopType.currentText()) ) 
-                    txCell.setFlags( QtCore.Qt.ItemIsEnabled )
-                    self.ui.txRxTable.setItem( len(self.loops.keys())-1, 3, txCell)
-
+                txCell = QtWidgets.QTableWidgetItem()
+                txCell.setText( str(self.ui.loopType.currentText()) ) 
+                txCell.setFlags( QtCore.Qt.ItemIsEnabled )
+                self.ui.txRxTable.setItem( len(self.loops.keys())-1, 3, txCell)
 
     def headerBoxShrink(self):
         #self.ui.headerFileBox.setVisible(False)
         #self.ui.loopTableWidget.itemClicked.connect(self.loopCellClicked) 
 
     def loopCellChanged(self):
-        self.ui.loopTableWidget.cellChanged.disconnect(self.loopCellChanged) 
         
+        self.ui.loopTableWidget.cellChanged.disconnect(self.loopCellChanged) 
         jj = self.ui.loopTableWidget.currentColumn()
         ii = self.ui.loopTableWidget.currentRow()
 
 
         for loop in self.loops:
             POINTS = self.loops[loop].GetPoints().T
-            self.ui.mplwidget.ax1.plot( POINTS[:,0], POINTS[:,1] )
-        
+            self.ui.mplwidget.ax1.plot( POINTS[:,1], POINTS[:,0], label=loop )
+       
+        self.ui.mplwidget.ax1.spines['right'].set_visible(False)
+        self.ui.mplwidget.ax1.spines['top'].set_visible(False) 
+        self.ui.mplwidget.ax1.set_xlabel("easting (m)")
+        self.ui.mplwidget.ax1.set_ylabel("northing (m)")
+        self.ui.mplwidget.ax1.legend()
         self.ui.mplwidget.ax1.set_aspect('equal') #, adjustable='box')
         self.ui.mplwidget.draw()
+    
+    def removeLoop(self):
+        del self.loops[ self.ui.txRxTable.item( self.ui.txRxTable.currentRow(), 0).text() ]
+        self.ui.txRxTable.removeRow(self.ui.txRxTable.currentRow()) 
 
     def plotLoops(self):
        
         splash.show()
     
     aw = ApplicationWindow()
-
     #img=mpimg.imread(logo)
     for ax in [ aw.ui.mplwidget ]: 
         ax.fig.clear()
         splash.finish(aw)
         #time.sleep(1) 
 
-    aw.setWindowTitle("Akvo v"+str(version)) 
+    aw.setWindowTitle("Akvo v"+str(VERSION)) 
     aw.show()
     qApp.setWindowIcon(QtGui.QIcon(logo2))
     sys.exit(qApp.exec_())

akvo/gui/logo.py

     ax.plot(x[o],  y4[o], linewidth=3, color='black')
     ax.plot(x[o], -y4[o], linewidth=3, color='black')
     ax.fill_between(x[o],  y4[o], y2=-y4[o],  where=y4[o]<=1, interpolate=True, linewidth=0, alpha=.95, color='maroon')
+
+if __name__ == "__main__":
+    import matplotlib.pyplot as plt 
+
+    fig = plt.figure( figsize=(6,3) )
+    #ax = fig.add_axes([.1,.1,.8,.8])
+    ax = fig.add_subplot(211)
+
+    fig.patch.set_facecolor( None )
+    fig.patch.set_alpha( .0 )
+    ax.axis('off')
+    plotLogo(ax)
+    ax.xaxis.set_major_locator(plt.NullLocator()) 
+    ax.yaxis.set_major_locator(plt.NullLocator()) 
+
+    subplot2 = fig.add_subplot(212)
+    subplot2.text(0.5, 1.,'surface NMR workbench',
+            horizontalalignment='center',
+            verticalalignment='center',
+            size=22,
+            transform = subplot2.transAxes)
+    subplot2.xaxis.set_major_locator(plt.NullLocator()) 
+    subplot2.yaxis.set_major_locator(plt.NullLocator()) 
+    subplot2.axis('off')
+    plt.savefig("logo.pdf")
+    plt.show()
+
 #ax.fill_between(x[o], -y4[o], y2=0, where=-y4[o]<=1, interpolate=True, linewidth=0, alpha=.5, color='black')
 #ax.plot(x[o], y2[o], linewidth=3, color='black')
 #ax.plot(x[o],-y2[o], linewidth=3, color='black')

akvo/gui/main.ui

            <enum>Qt::LeftToRight</enum>
           </property>
           <property name="currentIndex">
-           <number>3</number>
+           <number>0</number>
           </property>
           <property name="elideMode">
            <enum>Qt::ElideLeft</enum>
                  <property name="toolTip">
                   <string>Forgetting factor, how quickly does the filter adapt.</string>
                  </property>
+                 <property name="decimals">
+                  <number>3</number>
+                 </property>
                  <property name="minimum">
-                  <double>0.200000000000000</double>
+                  <double>0.950000000000000</double>
                  </property>
                  <property name="maximum">
                   <double>1.000000000000000</double>
               <rect>
                <x>0</x>
                <y>0</y>
-               <width>411</width>
-               <height>67</height>
+               <width>96</width>
+               <height>26</height>
               </rect>
              </property>
              <attribute name="label">

akvo/tressel/adapt.py

         with an adaptive filter that utilizes 2 reference signals instead of  
         the standard method which allows for only 1 reference signal.         
         Author: Rob Clemens              Date: 3/16/06                       
-        Modified and ported to Python, now takes arbitray number of reference points  
+        Modified and ported to Python, now takes arbitray number of reference points 
+        Original public domain source 
+        https://www.mathworks.com/matlabcentral/fileexchange/10447-noise-canceling-adaptive-filter 
+            x = data array 
+            R = reference array 
+            M = number of taps 
+            mu = forgetting factor 
+            PCA = Perform PCA 
         """
         #from akvo.tressel import pca 
         import akvo.tressel.pca as pca 
             #H0 = H0[0:2*np.shape(x)[0]]
 
         if all(H0) == 0:
+            # corrects for dimensionality issues if a simple 0 is passed
             H = np.zeros( (len(R)*M))
-            #print ("resetting filter")
         else:
             H = H0
-            #H = np.zeros( (len(R)*M))
 
         Rn = np.ones(len(R)*M) / mu 
         
         r_ = np.zeros( (len(R), M) ) 
-        e = np.zeros(len(x)) # error, desired output
+        e = np.zeros(len(x))           # error, in our case the desired output
         ilambda = lambda2**-1
 
-        for z in range(0, len(x)):
+        for ix in range(0, len(x)):
             # Only look forwards, to avoid distorting the lates times 
             # (run backwards, if opposite and you don't care about distorting very late time.)
-            for ir in range(len(R)):
-                if z < M:
-                    r_[ir,0:z] = R[ir][0:z]
-                    r_[ir,z:M] = 0 
+            for ir in range(len(R)):  # number of reference channels 
+                if ix < M:
+                    r_[ir,0:ix] = R[ir][0:ix]
+                    r_[ir,ix:M] = 0 
                 else:
-                    # TODO, use np.delete and np.append to speed this up
-                    r_[ir,:] = R[ir][z-M:z]
+                    r_[ir,:] = R[ir][ix-M:ix]
+
             # reshape            
-            r_n = np.reshape(r_, -1) #concatenate((r_v, r_h ))
+            r_n = np.reshape(r_, -1) # concatenate the ref channels in to a 1D array 
 
-            #K      = np.dot( np.diag(Rn,0), r_n) / (lambda2 + np.dot(r_n*Rn, r_n))  # Create/update K
-            K      = (Rn* r_n) / (lambda2 + np.dot(r_n*Rn, r_n))  # Create/update K
-            e[z]   = x[z] - np.dot(r_n.T, H)             # e is the filtered signal, input - r(n) * Filter Coefs
-            H     += K*e[z];                             # Update Filter Coefficients
-            Rn     = ilambda*Rn - ilambda*np.dot(np.dot(K, r_n.T), Rn)     # Update R(n)
+            K      = (Rn* r_n) / (lambda2 + np.dot(r_n*Rn, r_n))       # Create/update K
+            e[ix]  = x[ix] - np.dot(r_n.T, H)                          # e is the filtered signal, input - r(n) * Filter Coefs
+            H     += K*e[ix];                                          # Update Filter Coefficients
+            Rn     = ilambda*Rn - ilambda*np.dot(np.dot(K, r_n.T), Rn) # Update R(n)
         return e, H
 
     def transferFunctionFFT(self, D, R, reg=1e-2):
-        from akvo.tressel import pca
-        """
-            Computes the transfer function (H) between a Data channel and 
-            a number of Reference channels. The Matrices D and R are 
-            expected to be in the frequency domain on input.
-            | R1'R1 R1'R2 R1'R3|   |h1|   |R1'D|
-            | R2'R1 R2'R2 R2'R3| * |h2| = |R2'D|
-            | R3'R1 R3'R2 R3'R3|   |h3|   |R3'D|
-
-            Returns the corrected array 
-        """
-
-        # PCA decomposition on ref channels so signals are less related
-        #transMatrix, K, means = pca.pca( np.array([rx0, rx1]))   
-        #RR = np.zeros(( np.shape(R[0])[0]*np.shape(R[0])[1], len(R)))
-#         RR = np.zeros(( len(R), np.shape(R[0])[0]*np.shape(R[0])[1] ))
-#         for ir in range(len(R)):
-#             RR[ir,:] = np.reshape(R[ir], -1)
-#         transMatrix, K, means = pca.pca(RR)    
-#         #R rx0 = transMatrix[0,:]
-#         # rx1 = transMatrix[1,:]
-#         for ir in range(len(R)):
-#             R[ir] = transMatrix[ir,0]
-
-        import scipy.linalg 
-        import akvo.tressel.pca as pca 
-        # Compute as many transfer functions as len(R)
-        # A*H = B
-        nref = len(R)
-        H = np.zeros( (np.shape(D)[1], len(R)), dtype=complex )
-        for iw in range(np.shape(D)[1]):
-            A = np.zeros( (nref, nref), dtype=complex )
-            B = np.zeros( (nref) , dtype=complex)
-            for ii in range(nref):
-                for jj in range(nref):
-                    # build A
-                    A[ii,jj] = np.dot(R[ii][:,iw], R[jj][:,iw])                 
-
-                # build B
-                B[ii] = np.dot( R[ii][:,iw], D[:,iw] )
-
-            # compute H(iw)
-            #linalg.solve(a,b) if a is square
-            #print "A", A
-            #print "B", B
-            # TODO, regularise this solve step? So as to not fit the spurious noise
-            #print np.shape(B), np.shape(A) 
-            #H[iw, :] = scipy.linalg.solve(A,B)
-            H[iw, :] = scipy.linalg.lstsq(A,B,cond=reg)[0]
-            #print "lstqt", np.shape(scipy.linalg.lstsq(A,B))
-            #print "solve", scipy.linalg.solve(A,B)
-            #H[iw,:]  = scipy.linalg.lstsq(A,B) # otherwise 
-                #H = np.zeros( (np.shape(D)[1], )   )
-        #print H #A, B
-        Error = np.zeros(np.shape(D), dtype=complex)
-        for ir in range(nref):
-            for q in range( np.shape(D)[0] ):
-                #print "dimcheck", np.shape(H[:,ir]), np.shape(R[ir][q,:] )
-                Error[q,:] += H[:,ir]*R[ir][q,:]
-        return D - Error
-
-    def adapt_filt_tworefFreq(self, x, rx0, rx1, M, lambda2=0.95):
-        """ Frequency domain version of above
-        """
-        from akvo.tressel import pca 
-
-        pylab.figure()
-        pylab.plot(rx0)
-        pylab.plot(rx1)
-
-        # PCA decomposition on ref channels so signals are less related
-        transMatrix, K, means = pca.pca( np.array([rx0, rx1]))    
-        rx0 = transMatrix[:,0]
-        rx1 = transMatrix[:,1]
-        
-        pylab.plot(rx0)
-        pylab.plot(rx1)
-        pylab.show()
-        exit()
-
-        if np.shape(x) != np.shape(rx0) or np.shape(x) != np.shape(rx1):
-            print ("Error, non aligned")
-            exit(1)
-
-        wx = fft.rfft(x)
-        wr0 = fft.rfft(rx0)
-        wr1 = fft.rfft(rx1)
+         from akvo.tressel import pca
+         """
+             Computes the transfer function (H) between a Data channel and 
+             a number of Reference channels. The Matrices D and R are 
+             expected to be in the frequency domain on input.
+             | R1'R1 R1'R2 R1'R3|   |h1|   |R1'D|
+             | R2'R1 R2'R2 R2'R3| * |h2| = |R2'D|
+             | R3'R1 R3'R2 R3'R3|   |h3|   |R3'D|
  
-        H = np.zeros( (2*M), dtype=complex ) 
-        ident_mat = np.eye((2*M))
-        Rn = ident_mat / 0.1
-        r_v = np.zeros( (M), dtype=complex ) 
-        r_h = np.zeros( (M), dtype=complex ) 
-        e = np.zeros(len(x), dtype=complex )
-        ilambda = lambda2**-1
-
-        for z in range(0, len(wx)):
-            # TODO Padd with Zeros or truncate if M >,< arrays 
-            r_v = wr0[::-1][:M] 
-            r_h = wr1[::-1][:M] 
-            r_n = np.concatenate((r_v, r_h ))
-            K      = np.dot(Rn, r_n) / (lambda2 + np.dot(np.dot(r_n.T, Rn), r_n))  # Create/update K
-            e[z]   = wx[z] - np.dot(r_n,H)        # e is the filtered signal, input - r(n) * Filter Coefs
-            H     += K * e[z];                    # Update Filter Coefficients
-            Rn     = ilambda*Rn - ilambda*K*r_n.T*Rn  # Update R(n)
-        
-        return fft.irfft(e)
-
-    def iter_filt_refFreq(self, x, rx0, Ahat=.05, Bhat=.5, k=0.05):
-
-        X = np.fft.rfft(x)
-        X0 = np.copy(X)
-        RX0 = np.fft.rfft(rx0)
-
-        # step 0
-        Abs2HW = []
-        alphai =  k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) 
-        betai  =  k * (1. / (np.abs(Bhat)**2) ) 
-        Hw     =  ((1.+alphai) * np.abs(X)**2 ) / (np.abs(X)**2 + betai*(np.abs(RX0)**2))
-        H      =  np.abs(Hw)**2
-        pylab.ion()
-        pylab.figure()
-        for i in range(10):
-            #print "alphai", alphai
-            #print "betai", betai
-            #print "Hw", Hw
-            alphai = k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) * np.product(H, axis=0)
-            betai  = k * (1. / np.abs(Bhat)**2) * np.product(H, axis=0)
-            # update signal
-            Hw   =  ((1.+alphai) * np.abs(X)**2) / (np.abs(X)**2 + betai*np.abs(RX0)**2)
-            Hw = np.nan_to_num(Hw)
-            X *= Hw
-            H = np.vstack( (H, np.abs(Hw)**2) )
-            #print "Hw", Hw
-            pylab.cla()
-            pylab.plot(Hw)
-            #pylab.plot(np.abs(X))
-            #pylab.plot(np.abs(RX0))
-            pylab.draw()
-            raw_input("wait")
-
-        pylab.cla()
-        pylab.ioff()
-        #return np.fft.irfft(X0-X)
-        return np.fft.irfft(X)
-
-    def iter_filt_refFreq(self, x, rx0, rx1, Ahat=.1, Bhat=1., k=0.001):
-
-        X = np.fft.rfft(x)
-        X0 = np.copy(X)
-        RX0 = np.fft.rfft(rx0)
-        RX1 = np.fft.rfft(rx1)
-
-        # step 0
-        alphai =  k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) 
-        betai  =  k * (1. / (np.abs(Bhat)**2) ) 
-        #Hw     =  ((1.+alphai) * np.abs(X)**2 ) / (np.abs(X)**2 + betai*(np.abs(RX0)**2))
-        H      =  np.ones(len(X)) # abs(Hw)**2
-        #pylab.ion()
-        #pylab.figure(334)
-        for i in range(1000):
-            #print "alphai", alphai
-            #print "betai", betai
-            #print "Hw", Hw
-            alphai = k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) * np.product(H, axis=0)
-            betai  = k * (1. / np.abs(Bhat)**2) * np.product(H, axis=0)
-            # update signal
-            Hw   =  ((1.+alphai) * np.abs(X)**2) / (np.abs(X)**2 + betai*np.abs(RX0)**2)
-            Hw = np.nan_to_num(Hw)
-            X *= Hw #.conjugate
-            #H = np.vstack((H, np.abs(Hw)**2) )
-            H = np.vstack((H, np.abs(Hw)) )
-            #print "Hw", Hw
-            #pylab.cla()
-            #pylab.plot(Hw)
-            #pylab.plot(np.abs(X))
-            #pylab.plot(np.abs(RX0))
-            #pylab.draw()
-            #raw_input("wait")
-
-        #pylab.cla()
-        #pylab.ioff()
-        return np.fft.irfft(X0-X)
-        #return np.fft.irfft(X)
-
-    def Tdomain_DFT(self, desired, input, S):
-        """ Lifted from Adaptive filtering toolbox. Modefied to accept more than one input 
-            vector
-        """
-        
-        # Initialisation Procedure
-        nCoefficients =   S["filterOrderNo"]/2+1
-        nIterations   =   len(desired)
-
-        # Pre Allocations
-        errorVector  = np.zeros(nIterations, dtype='complex')
-        outputVector = np.zeros(nIterations, dtype='complex')
-        
-        # Initial State
-        coefficientVectorDFT =   np.fft.rfft(S["initialCoefficients"])/np.sqrt(float(nCoefficients))
-        desiredDFT           =   np.fft.rfft(desired)
-        powerVector          =   S["initialPower"]*np.ones(nCoefficients)
-
-        # Improve source code regularity, pad with zeros
-        # TODO, confirm zeros(nCoeffics) not nCoeffics-1
-        prefixedInput  =   np.concatenate([np.zeros(nCoefficients-1), np.array(input)])
-
-        # Body
-        pylab.ion()
-        pylab.figure(11)
-        for it in range(nIterations): # = 1:nIterations,
-            
-            regressorDFT = np.fft.rfft(prefixedInput[it:it+nCoefficients][::-1]) /\
-                           np.sqrt(float(nCoefficients))
-
-            # Summing two column vectors
-            powerVector = S["alpha"] * (regressorDFT*np.conjugate(regressorDFT)) + \
-                                  (1.-S["alpha"])*(powerVector)
-
-            pylab.cla()
-            #pylab.plot(prefixedInput[::-1], 'b')
-            #pylab.plot(prefixedInput[it:it+nCoefficients][::-1], 'g', linewidth=3)
-            #pylab.plot(regressorDFT.real)
-            #pylab.plot(regressorDFT.imag)
-            pylab.plot(powerVector.real)
-            pylab.plot(powerVector.imag)
-            #pylab.plot(outputVector)
-            #pylab.plot(errorVector.real)
-            #pylab.plot(errorVector.imag)
-            pylab.draw()
-            #raw_input("wait")
-
-            outputVector[it] = np.dot(coefficientVectorDFT.T, regressorDFT)
-
-            #errorVector[it] = desired[it] - outputVector[it]
-            errorVector[it] = desiredDFT[it] - outputVector[it]
-
-            #print errorVector[it], desired[it], outputVector[it]
-
-            # Vectorized
-            coefficientVectorDFT += (S["step"]*np.conjugate(errorVector[it])*regressorDFT) /\
-                                    (S['gamma']+powerVector)
-
-        return np.real(np.fft.irfft(errorVector))
-        #coefficientVector = ifft(coefficientVectorDFT)*sqrt(nCoefficients);
-
-    def Tdomain_DCT(self, desired, input, S):
-        """ Lifted from Adaptive filtering toolbox. Modefied to accept more than one input 
-            vector. Uses cosine transform
-        """
-        from scipy.fftpack import dct
+             Returns the corrected array 
+         """
  
-        # Initialisation Procedure
-        nCoefficients =   S["filterOrderNo"]+1
-        nIterations   =   len(desired)
-
-        # Pre Allocations
-        errorVector  = np.zeros(nIterations)
-        outputVector = np.zeros(nIterations)
-        
-        # Initial State
-        coefficientVectorDCT =   dct(S["initialCoefficients"]) #/np.sqrt(float(nCoefficients))
-        desiredDCT           =   dct(desired)
-        powerVector          =   S["initialPower"]*np.ones(nCoefficients)
-
-        # Improve source code regularity, pad with zeros
-        prefixedInput  =   np.concatenate([np.zeros(nCoefficients-1), np.array(input)])
-        
-        # Body
-        #pylab.figure(11)
-        #pylab.ion()
-        for it in range(0, nIterations): # = 1:nIterations,
-            
-            regressorDCT = dct(prefixedInput[it:it+nCoefficients][::-1], type=2) 
-            #regressorDCT = dct(prefixedInput[it+nCoefficients:it+nCoefficients*2+1])#[::-1]) 
-
-            # Summing two column vectors
-            powerVector = S["alpha"]*(regressorDCT) + (1.-S["alpha"])*(powerVector)
-            #pylab.cla()
-            #pylab.plot(powerVector)
-            #pylab.draw()
-
-            outputVector[it] = np.dot(coefficientVectorDCT.T, regressorDCT)
-            #errorVector[it] = desired[it] - outputVector[it]
-            errorVector[it] = desiredDCT[it] - outputVector[it]
-
-            # Vectorized
-            coefficientVectorDCT += (S["step"]*errorVector[it]*regressorDCT) #/\
-                                    #(S['gamma']+powerVector)
-
-        #pylab.plot(errorVector)
-        #pylab.show()
-        return dct(errorVector, type=3)
-        #coefficientVector = ifft(coefficientVectorDCT)*sqrt(nCoefficients);
-
-
-
-    def Tdomain_CORR(self, desired, input, S):
-
-        from scipy.linalg import toeplitz
-        from scipy.signal import correlate
-
-        # Autocorrelation
-        ac = np.correlate(input, input, mode='full')
-        ac = ac[ac.size/2:]
-        R = toeplitz(ac)
-        
-        # cross correllation
-        r = np.correlate(desired, input, mode='full')
-        r = r[r.size/2:]
-        
-        #r = np.correlate(desired, input, mode='valid')
-        print ("R", np.shape(R))
-        print ("r", np.shape(r))
-        print ("solving")
-        #H = np.linalg.solve(R,r)
-        H = np.linalg.lstsq(R,r,rcond=.01)[0]
-        #return desired - np.dot(H,input)
-        print ("done solving")
-        pylab.figure()
-        pylab.plot(H)
-        pylab.title("H")
-        #return desired - np.convolve(H, input, mode='valid')
-        #return desired - np.convolve(H, input, mode='same')
-        #return np.convolve(H, input, mode='same')
-        return desired - np.dot(toeplitz(H), input)
-        #return np.dot(R, H)
-
-#         T = toeplitz(input)
-#         print "shapes", np.shape(T), np.shape(desired)
-#         h = np.linalg.lstsq(T, desired)[0]
-#         print "shapes", np.shape(h), np.shape(input)
-#         #return np.convolve(h, input, mode='same')
-#         return desired - np.dot(T,h)
+         # PCA decomposition on ref channels so signals are less related
+         #transMatrix, K, means = pca.pca( np.array([rx0, rx1]))   
+         #RR = np.zeros(( np.shape(R[0])[0]*np.shape(R[0])[1], len(R)))
+ #         RR = np.zeros(( len(R), np.shape(R[0])[0]*np.shape(R[0])[1] ))
+ #         for ir in range(len(R)):
+ #             RR[ir,:] = np.reshape(R[ir], -1)
+ #         transMatrix, K, means = pca.pca(RR)    
+ #         #R rx0 = transMatrix[0,:]
+ #         # rx1 = transMatrix[1,:]
+ #         for ir in range(len(R)):
+ #             R[ir] = transMatrix[ir,0]
  
-    def Fdomain_CORR(self, desired, input, dt, freq):
-        
-        from scipy.linalg import toeplitz
-        
-        # Fourier domain
-        Input = np.fft.rfft(input)
-        Desired = np.fft.rfft(desired)
-
-        T = toeplitz(Input)
-        #H = np.linalg.solve(T, Desired)
-        H = np.linalg.lstsq(T, Desired)[0]
-#         ac = np.correlate(Input, Input, mode='full')
-#         ac = ac[ac.size/2:]
-#         R = toeplitz(ac)
-#         
-#         r = np.correlate(Desired, Input, mode='full')
-#         r = r[r.size/2:]
-#         
-#         #r = np.correlate(desired, input, mode='valid')
-#         print "R", np.shape(R)
-#         print "r", np.shape(r)
-#         print "solving"
-#         H = np.linalg.solve(R,r)
-#         #H = np.linalg.lstsq(R,r)
-#         #return desired - np.dot(H,input)
-#         print "done solving"
-        pylab.figure()
-        pylab.plot(H.real)
-        pylab.plot(H.imag)
-        pylab.plot(Input.real)
-        pylab.plot(Input.imag)
-        pylab.plot(Desired.real)
-        pylab.plot(Desired.imag)
-        pylab.legend(["hr","hi","ir","ii","dr","di"])
-        pylab.title("H")
-        #return desired - np.fft.irfft(Input*H)
-        return np.fft.irfft(H*Input)
-
-    def Tdomain_RLS(self, desired, input, S):
-        """
-            A DFT is first performed on the data. Than a RLS algorithm is carried out 
-            for noise cancellation. Related to the RLS_Alt Algoritm 5.3 in  Diniz book.
-            The desired and input signals are assummed to be real time series data.
-        """
-
-        # Transform data into frequency domain
-        Input = np.fft.rfft(input)
-        Desired = np.fft.rfft(desired)
-
-        # Initialisation Procedure
-        nCoefficients = S["filterOrderNo"]+1
-        nIterations   = len(Desired)
-
-        # Pre Allocations
-        errorVector  = np.zeros(nIterations, dtype="complex")
-        outputVector = np.zeros(nIterations, dtype="complex")
-        errorVectorPost  = np.zeros(nIterations, dtype="complex")
-        outputVectorPost = np.zeros(nIterations, dtype="complex")
-        coefficientVector = np.zeros( (nCoefficients, nIterations+1), dtype="complex" )        
-
-        # Initial State
-        coefficientVector[:,1] = S["initialCoefficients"]  
-        S_d                    = S["delta"]*np.eye(nCoefficients)
-
-        # Improve source code regularity, pad with zeros
-        prefixedInput = np.concatenate([np.zeros(nCoefficients-1, dtype="complex"), 
-                                np.array(Input)])
-        invLambda = 1./S["lambda"]
-        
-        # Body
-        pylab.ion()
-        pylab.figure(11)
-
-        for it in range(nIterations):
-            
-            regressor = prefixedInput[it:it+nCoefficients][::-1]
-
-            # a priori estimated output
-            outputVector[it] = np.dot(coefficientVector[:,it].T, regressor)
-       
-            # a priori error
-            errorVector[it] = Desired[it] - outputVector[it]
-
-            psi             = np.dot(S_d, regressor)
-            if np.isnan(psi).any():
-                print ("psi", psi)
-                exit(1)
-            
-            pylab.cla()
-            #pylab.plot(psi)
-            pylab.plot(regressor.real)
-            pylab.plot(regressor.imag)
-            pylab.plot(coefficientVector[:,it].real)
-            pylab.plot(coefficientVector[:,it].imag)
-            pylab.legend(["rr","ri", "cr", "ci"])
-            pylab.draw()
-            raw_input("paws")
-
-            S_d             = invLambda * (S_d - np.dot(psi, psi.T)  /\
-                                S["lambda"] + np.dot(psi.T, regressor))
-
-            coefficientVector[:,it+1] = coefficientVector[:,it] + \
-                                        np.conjugate(errorVector[it])*np.dot(S_d, regressor)
-            # A posteriori estimated output
-            outputVectorPost[it]  =  np.dot(coefficientVector[:,it+1].T, regressor)
-
-            # A posteriori error
-            errorVectorPost[it] = Desired[it] - outputVectorPost[it]
+         import scipy.linalg 
+         import akvo.tressel.pca as pca 
+         # Compute as many transfer functions as len(R)
+         # A*H = B
+         nref = len(R)
+         H = np.zeros( (np.shape(D)[1], len(R)), dtype=complex )
+         for iw in range(np.shape(D)[1]):
+             A = np.zeros( (nref, nref), dtype=complex )
+             B = np.zeros( (nref) , dtype=complex)
+             for ii in range(nref):
+                 for jj in range(nref):
+                     # build A
+                     A[ii,jj] = np.dot(R[ii][:,iw], R[jj][:,iw])                 
  
-        errorVectorPost = np.nan_to_num(errorVectorPost)
-
-        pylab.figure(11)
-        print (np.shape(errorVectorPost))
-        pylab.plot(errorVectorPost.real)
-        pylab.plot(errorVectorPost.imag)
-        pylab.show()
-        print(errorVectorPost)
-        #return np.fft.irfft(Desired)
-        return np.fft.irfft(errorVectorPost)
-
-if __name__ == "__main__":
-
-    def noise(nu, t, phi):
-        return np.sin(nu*2.*np.pi*t + phi)
+                 # build B
+                 B[ii] = np.dot( R[ii][:,iw], D[:,iw] )
+ 
+             # compute H(iw)
+             #linalg.solve(a,b) if a is square
+             #print "A", A
+             #print "B", B
+             # TODO, regularise this solve step? So as to not fit the spurious noise
+             #print np.shape(B), np.shape(A) 
+             #H[iw, :] = scipy.linalg.solve(A,B)
+             H[iw, :] = scipy.linalg.lstsq(A,B,cond=reg)[0]
+             #print "lstqt", np.shape(scipy.linalg.lstsq(A,B))
+             #print "solve", scipy.linalg.solve(A,B)
+             #H[iw,:]  = scipy.linalg.lstsq(A,B) # otherwise 
+                 #H = np.zeros( (np.shape(D)[1], )   )
+         #print H #A, B
+         Error = np.zeros(np.shape(D), dtype=complex)
+         for ir in range(nref):
+             for q in range( np.shape(D)[0] ):
+                 #print "dimcheck", np.shape(H[:,ir]), np.shape(R[ir][q,:] )
+                 Error[q,:] += H[:,ir]*R[ir][q,:]
+         return D - Error
 
-    import matplotlib.pyplot as plt
-    print("Test driver for adaptive filtering")
-    Filt = AdaptiveFilter(.1)
-    t = np.arange(0, .5, 1e-4)
-    omega = 2000 * 2.*np.pi
-    T2 = .100
-    n1 = noise(60, t, .2   )
-    n2 = noise(61, t, .514 )
-    x = np.sin(omega*t)* np.exp(-t/T2) + 2.3*noise(60, t, .34) + 1.783*noise(31, t, 2.1)
-    e = Filt.adapt_filt_tworef(x, n1, n2, 200, .98)
-    plt.plot(t,  x)
-    plt.plot(t, n1)
-    plt.plot(t, n2)
-    plt.plot(t,  e)
-    plt.show()

akvo/tressel/harmonic.py

     if Nsearch != False:
         kNs = k1+Nsearch    
     if Bounds == 0:
-        print("UNbounded search from ", k1, " to ", kNs) # for f0 with fN=10 in search", f0)
         # CG, BFGS, Newton-CG, L-BFGS-B, TNC, SLSQP, dogleg, trust-ncg, trust-krylov, trust-exact and trust-constr
         res = minimize(harmonicNorm, np.array((f0)), args=(sN, fs, t, k1, kNs, ks), jac='2-point', method='BFGS') # hess=None, bounds=None )
+        print("UNbounded search from ", k1, " to ", kNs, res.x[0]) # for f0 with fN=10 in search", f0)
     
     else:
         bnds = ( (f0-Bounds, f0+Bounds), )
-        print("bounded ( +-", Bounds, ") search from ", k1, "to", kNs) # for f0 with fN=10 in search", f0)
         res = minimize(harmonicNorm, (f0,), args=(sN, fs, t, k1, kNs, ks), jac='2-point', method='L-BFGS-B', bounds=bnds ) # hess=None, bounds=None )
+        print("bounded ( +-", Bounds, ") search from ", k1, "to", kNs, res.x[0]) # for f0 with fN=10 in search", f0)
 
     return harmonicEuler(sN, fs, t, res.x[0], k1, kN, ks), res.x[0]#[0]
 

akvo/tressel/mrsurvey.py

 import multiprocessing 
 import itertools 
 
+import padasip as pa
+
 import akvo.tressel.adapt as adapt
 #import akvo.tressel.cadapt as adapt # cython for more faster
 import akvo.tressel.decay as decay
                                     X = np.fft.rfft(self.DATADICT[pulse][ichan][ipm][istack])
                                     canvas.ax1.plot(np.abs(ww[0:len(X)]), np.abs(X), alpha=.5)
                             canvas.ax1.set_prop_cycle(None)
-                            #canvas.ax1.set_ylim(-mmaxr, mmaxr) 
+                            canvas.ax1.set_ylim(-mmaxr, mmaxr) 
                         for ichan in self.DATADICT[pulse]["chan"]:
                             if TDPlot:
                                 canvas.ax2.plot( self.DATADICT[pulse]["TIMES"], 1e9*self.DATADICT[pulse][ichan][ipm][istack], alpha=.5) 
                                 X = np.fft.rfft(self.DATADICT[pulse][ichan][ipm][istack])
                                 canvas.ax2.plot(np.abs(ww[0:len(X)]), np.abs(X), alpha=.5)
                         canvas.ax2.set_prop_cycle(None)
-                        #canvas.ax2.set_ylim(-mmaxd, mmaxd)
+                        canvas.ax2.set_ylim(-mmaxd, mmaxd)
                     if procRefs: 
                         for ichan in self.DATADICT[pulse]["rchan"]:
                             if nF == 1:
 
                     # calculate effective current/moment
                     I0 = np.abs(X)/len(X) 
-                    qeff = I0 #* (self.DATADICT[pulse]["PULSE_TIMES"][-1]-self.DATADICT[pulse]["PULSE_TIMES"][0])
+                    qeff = I0 * (self.DATADICT[pulse]["PULSE_TIMES"][-1]-self.DATADICT[pulse]["PULSE_TIMES"][0])
 
                     # frequency plot
                     #canvas.ax1.set_title(r"pulse moment index " +str(ipm), fontsize=10)
         for pulse in self.DATADICT["PULSES"]:
             H[pulse] = {}
             for ichan in self.DATADICT[pulse]["chan"]:
-                H[pulse][ichan] = np.zeros(M)
+                H[pulse][ichan] = np.zeros(M*len( self.DATADICT[pulse]["rchan"] ))
         
         iFID = 0 
         # original ordering... 
                         mmax = max(mmax, np.max(1e9*self.DATADICT[pulse][ichan][ipm][istack])) 
                     canvas.ax2.set_ylim(-mmax, mmax) 
                     canvas.ax2.set_prop_cycle(None)
-
                     for ichan in self.DATADICT[pulse]["chan"]:
                         #H = np.zeros(M)
                         RX = []
                         for irchan in self.DATADICT[pulse]["rchan"]:
                             RX.append(self.DATADICT[pulse][irchan][ipm][istack][::-1])
-                        if all(H[pulse][ichan]) == 0:
-                            # call twice to reconcile filter wind-up
-                            [e,H[pulse][ichan]] = Filt.adapt_filt_Ref( self.DATADICT[pulse][ichan][ipm][istack][::-1],\
-                                                        RX,\
-                                                        M, mu, PCA, flambda, H[pulse][ichan])
-                            [e,H[pulse][ichan]] = Filt.adapt_filt_Ref( self.DATADICT[pulse][ichan][ipm][istack][::-1],\
+                        # Reset each time? 
+                        #H[pulse][ichan] *= 0
+                        #if all(H[pulse][ichan]) == 0:
+                        if False: 
+                            ####################################################################################
+                            # Padasip adaptive filter implimentations, do not allow for variable filter length
+                            ####################################################################################
+                            # identification                                                                   #
+                            #f = pa.filters.FilterRLS(n=len(self.DATADICT[pulse]["rchan"]), mu=0.99, w="zeros") #
+                            #f = pa.filters.FilterGNGD(n=len(self.DATADICT[pulse]["rchan"]), mu=0.1)           #                          # Nope
+                            #f = pa.filters.FilterLMS(n=len(self.DATADICT[pulse]["rchan"]), mu=0.1)            #                          # NOPE
+                            #f = pa.filters.AdaptiveFilter(model="NLMS", n=len(self.DATADICT[pulse]["rchan"]), mu=0.1, w="random")        # NOPE  
+                            #f = pa.filters.AdaptiveFilter(model="GNGD", n=len(self.DATADICT[pulse]["rchan"]), mu=0.1)                    # horrendous
+                            #f = pa.filters.FilterNLMF(n=len(self.DATADICT[pulse]["rchan"]), mu=0.005, w="random")                        # BAD
+                            
+                            #f = pa.filters.FilterSSLMS(n=len(self.DATADICT[pulse]["rchan"]), mu=0.01, w="zeros")                         # pretty good
+                            f = pa.filters.FilterNSSLMS(n=len(self.DATADICT[pulse]["rchan"]), mu=0.1, w="zeros")                          # pretty good 
+
+                            y, e, H[pulse][ichan] = f.run(self.DATADICT[pulse][ichan][ipm][istack][::-1], np.array(RX).T)    #
+                            ####################################################################################
+                            e = self.DATADICT[pulse][ichan][ipm][istack][::-1] - y
+                        elif True:
+                            # check for change in filter coefficients and rerun if things are changing too rapidly, 
+                            #       this is especially true for the first run 
+                            hm1 = np.copy(H[pulse][ichan]) 
+                            [e, H[pulse][ichan]] = Filt.adapt_filt_Ref( self.DATADICT[pulse][ichan][ipm][istack][::-1],\
+                                                     RX,\
+                                                     M, mu, PCA, flambda, H[pulse][ichan])
+                            iloop = 0
+                            #while False: 
+                            while (np.linalg.norm( H[pulse][ichan] - hm1) > .05):
+                                hm1 = np.copy(H[pulse][ichan]) 
+                                [e, H[pulse][ichan]] = Filt.adapt_filt_Ref( self.DATADICT[pulse][ichan][ipm][istack][::-1],\
                                                         RX,\
                                                         M, mu, PCA, flambda, H[pulse][ichan])
+                                iloop += 1
+                            print("Recalled ", iloop, "times with norm=", np.linalg.norm(hm1-H[pulse][ichan]))
                         else:
                             [e,H[pulse][ichan]] = Filt.adapt_filt_Ref( self.DATADICT[pulse][ichan][ipm][istack][::-1],\
                                                         RX,\
                             canvas.ax2.plot( self.DATADICT[pulse]["TIMES"], 1e9* e[::-1],\
                                 label = pulse + " ipm=" + str(ipm) + " istack=" + str(istack) + " ichan="  + str(ichan))
                             self.DATADICT[pulse][ichan][ipm][istack] = e[::-1]
-                            
-                        canvas.ax1.plot( H[pulse][ichan] ) # , label="taps") 
+                           
+     
+                        canvas.ax1.plot( H[pulse][ichan].reshape(-1, len(RX)) ) # , label="taps") 
+
                         canvas.ax2.legend(prop={'size':6}, loc='upper right')
                         #canvas.ax2.legend(prop={'size':6}, loc='upper right')
 
+                        mh = np.max(np.abs( H[pulse][ichan] ))
+                        canvas.ax1.set_ylim( -mh, mh )
+
                         canvas.ax2.set_xlabel(r"time [s]", fontsize=8)
                         canvas.ax2.set_ylabel(r"signal [nV]", fontsize=8)
 
         Filt = adapt.AdaptiveFilter(0.)
         for pulse in self.DATADICT["PULSES"]:
             # Compute window function and dimensions      
-            [WINDOW, nd, wstart, wend, dead] = self.computeWindow(pulse, band, centre, ftype) 
+            [WINDOW, nd, wstart, wend, dead, idead] = self.computeWindow(pulse, band, centre, ftype) 
             for istack in self.DATADICT["stacks"]:
                 for ichan in self.DATADICT[pulse]["chan"]:
                     # FFT of stack
 
                     canvas.ax3.legend(prop={'size':6}, loc='upper right')
                     canvas.ax2.legend(prop={'size':6}, loc='upper right')
-                    
-                    canvas.ax1.set_title("stack "+str(istack)+" pulse index " + str(ipm), fontsize=8)
+
                     canvas.ax1.set_ylabel("Current [A]", fontsize=8) 
                     canvas.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y') 
+                    canvas.ax1.set_xlabel("time [s]", fontsize=8)
                     
+                    canvas.ax2.set_title("stack "+str(istack)+" pulse index " + str(ipm), fontsize=8)
                     canvas.ax2.set_ylabel("RAW signal [V]", fontsize=8)
                     canvas.ax3.set_ylabel("RAW signal [V]", fontsize=8)
                     canvas.ax2.tick_params(axis='both', which='major', labelsize=8)
                     canvas.ax2.tick_params(axis='both', which='minor', labelsize=6)
-                    canvas.ax2.set_xlabel("time [s]", fontsize=8)
+
                     canvas.draw()
 
             percent = (int) (1e2*((float)((iistack*self.nPulseMoments+ipm+1))  / (len(procStacks)*self.nPulseMoments)))

pyuic.json

         [
             "akvo/gui/addCircularLoop.ui",
             "akvo/gui"
+        ],
+        [
+            "akvo/gui/addFigure8Loop.ui",
+            "akvo/gui"
         ]
     ],
     "pyrcc": "pyrcc5",

setup.py

     long_description = fh.read()
 
 setup(name='Akvo',
-      version='1.3.0',
+      version='1.3.1',
+      python_requires='>3.7.0', # due to pyLemma
       description='Surface nuclear magnetic resonance workbench',
       long_description=long_description,
       long_description_content_type='text/markdown',
 #          'rpy2',
           'matplotlib',
           'scipy',
+          'padasip',
           'numpy',
           'pyqt5',
           'pyyaml',
       # Mechanism to include auxiliary files
       include_package_data=True,
       package_data={
-        'akvo.gui': ['*.png'],  #All .r files 
-        'akvo.lemma': ['pyLemmaCore.so']
+        'akvo.gui': ['*.png'], 
+        'akvo.gui': ['*.ui']
       },
       classifiers=[
         "Programming Language :: Python :: 3",