Fix to bug not allowing Rx loops to be different from Tx

akvo/gui/akvoGUI.py

             print("txCoil", txCoil.text())
             txCoils.append(txCoil.text())
         
-        rxCoilList = self.ui.txListWidget.selectedItems() #currentItem().text() 
+        rxCoilList = self.ui.rxListWidget.selectedItems() #currentItem().text() 
         rxCoils = []
         for rxCoil in rxCoilList:
             print("rxCoil", rxCoil.text())
         #self.ui.lcdNumberResampFreq.display( self.RAWDataProc.samp )
  
         self.mpl_toolbar = NavigationToolbar2QT(self.ui.mplwidget, self.ui.mplwidget)
-        self.ui.mplwidget.draw()
+        #self.ui.mplwidget.draw() # this was crashing? 
 
     def loadRAW(self):
 

akvo/gui/main.ui

            <enum>Qt::LeftToRight</enum>
           </property>
           <property name="currentIndex">
-           <number>0</number>
+           <number>4</number>
           </property>
           <property name="elideMode">
            <enum>Qt::ElideLeft</enum>
               <rect>
                <x>0</x>
                <y>0</y>
-               <width>96</width>
-               <height>26</height>
+               <width>411</width>
+               <height>67</height>
               </rect>
              </property>
              <attribute name="label">

akvo/terminal/plotyaml.py → akvo/terminal/plotData.py

 import numpy as np
 
 import matplotlib.pyplot as plt
+
 import seaborn as sns
 sns.set(style="ticks")
+
 import cmocean 
 from SEGPlot import *
 from matplotlib.ticker import FormatStrFormatter
                     IM[q] = akvo.Gated[pulse][chan]["Q-" + str(q)+" IM"].data
                     #X[q] = akvo.Gated[pulse][chan]["Q-" + str(q)+" RE"].data
             Windows = akvo.Gated[pulse]["windows"].data
+            Centres = akvo.Gated[pulse]["abscissa"].data
+            
+
             Q = np.array(akvo.Pulses[pulse]["current"].data)
             print("pulse length ", akvo.pulseLength[0])
             Q *= akvo.pulseLength[0]
        
             fig = plt.figure( figsize=( pc2in(20), pc2in(26) ) ) 
             ax1 = fig.add_axes([.25,.05,.6,.9])
-            im = ax1.pcolormesh(Windows,Q,CA, cmap=cmocean.cm.curl_r, vmin=-np.max(np.abs(CA)), vmax=(np.max(np.abs(CA))))
+            #im = ax1.pcolormesh(Windows, Q, CA, cmap=cmocean.cm.curl_r, vmin=-np.max(np.abs(CA)), vmax=(np.max(np.abs(CA))))
+            im = ax1.pcolormesh(Centres, Q, CA, cmap=cmocean.cm.curl_r, vmin=-np.max(np.abs(CA)), vmax=(np.max(np.abs(CA))))
             cb = plt.colorbar( im, orientation='horizontal', pad=.175,  )
             cb.set_label("FID (nV)", fontsize=10)
             cb.ax.tick_params(labelsize=10) 
     #plt.matshow(IM)
     plt.savefig("data.pgf")
     plt.savefig("data.png", dpi=300)
-    #plt.show()
+    plt.show()
 
 if __name__ == "__main__":
     akvo = loadAkvoData( sys.argv[1] ) #, "Chan. 1")

akvo/terminal/plotKernel.py

     K = 1e9*catLayers(K0.K0)
     q = np.array(K0.PulseI.data)* (float)(K0.Taup)
 
+    centres = (np.array(K0.Interfaces.data[0:-1]) + np.array(K0.Interfaces.data[1::])) / 2
+
     fig = plt.figure( figsize=(pc2in(20),pc2in(20)) )
     fig.add_axes((.2,.2,.65,.7))
     #plt.pcolor(K0.Interfaces.data, K0.PulseI.data, np.abs(K))
     #plt.pcolor(q, K0.Interfaces.data, np.abs(K), cmap=cmocean.cm.gray_r)
     #plt.contourf(q, K0.Interfaces.data[0:-1], np.abs(K), cmap=cmocean.cm.tempo)
-    plt.pcolor(q, K0.Interfaces.data, np.abs(K), cmap=cmocean.cm.tempo)
+    #plt.pcolormesh(q, K0.Interfaces.data, np.abs(K), cmap=cmocean.cm.tempo, shading='nearest')
+    plt.pcolormesh(q, centres, np.abs(K), cmap=cmocean.cm.tempo, shading='nearest')
     plt.colorbar(label=r"$\left| \overline{\mathcal{V}_N}(0) \right|$ (nV)")
 
     ax1 = plt.gca()
     plt.gca().set_ylabel("depth (m)")
     plt.savefig("kernel.pdf")
 
-    sound = np.sum(K, axis=0)
-    plt.figure()
-    plt.plot(q, np.abs(sound))
-
-    
-
-    plt.savefig("sound.pdf")
+    #sound = np.sum(K, axis=0)
+    #plt.figure()
+    #plt.plot(q, np.abs(sound))
+    #plt.savefig("sound.pdf")
 
     plt.show()
     #print(yaml.dump(K0))

akvo/tressel/calcAkvoKernel.py

         print ("usage  akvoKO   AkvoDataset.yaml   kparams.yaml  SaveString.yaml " )
         exit()
 
+    print("Loading data")
     AKVO = loadAkvoData(sys.argv[1])
 
+    print("Building Kernel")
     B_inc = AKVO.META["B_0"]["inc"]  
     B_dec = AKVO.META["B_0"]["dec"]  
     B0    = AKVO.META["B_0"]["intensity"]  
 
     ## TODO 
     # pass this in...
+    print("Building layered earth model")
     lmod = em1d.LayeredEarthEM() 
 
     nlay = len(kparams["sigs"])

akvo/tressel/invertTA.py

 
 import pandas as pd
 
+# For Mihai, but consider letting fonts be user selected. 
+#import matplotlib.pyplot as plt
+#plt.rcParams["font.family"] = "arial"
 
 import matplotlib.colors as colors
 
     #Z *= 1e-9 
     #ZS *= 1e-9 
 
-    J = AKVO.Pulses["Pulse 1"]["current"].data 
-    J = np.append(J,J[-1]+(J[-1]-J[-2]))
+    J = np.array(AKVO.Pulses["Pulse 1"]["current"].data) 
+    #J = np.append(J,J[-1]+(J[-1]-J[-2])) # This was a pcolor hack, get rid of this
+    #print("J", J)
     Q = AKVO.pulseLength[0]*J
     return Z, ZS, AKVO.Gated["Pulse 1"]["abscissa"].data, Q
 
         ax3.set_xlabel("time (s)")
 
         #TT, QQQ = np.meshgrid(tg, np.ravel(QQ))
-        
         TT, QQQ = np.meshgrid(tg, np.ravel(QQ[ich]))
-        nq = np.shape(QQ[ich])[0] - 1 # to account for padding in pcolor 
+
+        nq = np.shape(QQ[ich])[0] #- 1               # -1 to account for padding in pcolor, but this was changed 
         nt = np.shape(tg)[0]
         ntq = nt*nq
         
-        VV = V[ich*nq:ich*nq+nq,:]   # slice this channel
+        VV  =  V[ich*nq:ich*nq+nq,:] # slice this channel
         VVS = VS[ich*nq:ich*nq+nq,:] # slice this channel
 
         mmax = np.max(np.abs(VV))
             #TT, QQQ = np.meshgrid(tg, np.ravel(QQ))
         
             TT, QQQ = np.meshgrid(tg, np.ravel(QQ[ich]))
-            nq = np.shape(QQ[ich])[0] - 1 # to account for padding in pcolor 
+            nq = np.shape(QQ[ich])[0]  # to account for padding in pcolor, this changed 
             nt = np.shape(tg)[0]
             ntq = nt*nq
         

akvo/tressel/logbarrier.py

 from __future__ import division
 import numpy as np
-from scipy.sparse.linalg import iterative  as iter
+try:
+    from scipy.sparse.linalg import iterative  as iter
+except:  # newer python gets rid of iterative module
+    import scipy.sparse.linalg as iter 
+
 from scipy.sparse import eye as seye
 import pylab 
 import pprint 

akvo/tressel/mrsurvey.py

                 ax2 = axes[2*ichan+1] 
                 
                 if phase == 0:
-                    im1 = ax1.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["RE"], cmap=dcmap, vmin=-vmax1, vmax=vmax1)
-                    im2 = ax2.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["IM"], cmap=dcmap, vmin=-vmax2, vmax=vmax2)
+                    im1 = ax1.pcolormesh(self.GATED[chan]["GT"], self.GATED[chan]["QQ"], self.GATED[chan]["RE"], shading='nearest', cmap=dcmap, vmin=-vmax1, vmax=vmax1)
+                    im2 = ax2.pcolormesh(self.GATED[chan]["GT"], self.GATED[chan]["QQ"], self.GATED[chan]["IM"], shading='nearest', cmap=dcmap, vmin=-vmax2, vmax=vmax2)
                     #im1 = ax1.matshow(self.GATED[chan]["RE"], cmap=dcmap, vmin=-vmax1, vmax=vmax1, aspect='auto')
                     #im2 = ax2.matshow(self.GATED[chan]["IM"], cmap=dcmap, vmin=-vmax2, vmax=vmax2, aspect='auto')
                 elif phase == 1:
-                    im1 = ax1.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["CA"], cmap=dcmap, vmin=-vmax1, vmax=vmax1)
-                    im2 = ax2.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["IP"], cmap=cmocean.cm.delta, vmin=-vmax2, vmax=vmax2)
+                    im1 = ax1.pcolormesh(self.GATED[chan]["GT"], self.GATED[chan]["QQ"], self.GATED[chan]["CA"], shading='nearest', cmap=dcmap, vmin=-vmax1, vmax=vmax1)
+                    im2 = ax2.pcolormesh(self.GATED[chan]["GT"], self.GATED[chan]["QQ"], self.GATED[chan]["IP"], shading='nearest', cmap=cmocean.cm.delta, vmin=-vmax2, vmax=vmax2)
                     #im2 = ax2.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["IP"], cmap=cmocean.cm.phase, vmin=-vmax2, vmax=vmax2)
                 elif phase == 2:
-                    im1 = ax1.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["CA"], cmap=dcmap, vmin=-vmax1, vmax=vmax1)
+                    im1 = ax1.pcolormesh(self.GATED[chan]["GT"], self.GATED[chan]["QQ"], self.GATED[chan]["CA"], shading='nearest', cmap=dcmap, vmin=-vmax1, vmax=vmax1)
                     #XS = self.bootstrap_sigma(pulse, chan)
                     #im2 = ax2.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["NR"], cmap=cmap, vmin=-vmax2, vmax=vmax2)
                     # bootstrap resample

akvo/tressel/nonlinearinv.py

 def PHI(m, Wd, K, d_obs, Wm, alphastar):
     """
         Global objective function 
-        x = model to be fit 
+        m = model to be fit, unknown 'x' 
         Wd = data weighting matrix 
         K = complex forward modelling kernel 
         d_obs = observed data (modulus)

setup.py

     long_description = fh.read()
 
 setup(name='Akvo',     
-      version='1.7.2', 
+      version='1.7.3', 
       python_requires='>3.7.0', # due to pyLemma 
       description='Surface nuclear magnetic resonance workbench',
       long_description=long_description,