Tweaks for plots in FastTIMES

akvo/gui/akvoGUI.py

         #INFO["samp"] = self.RAWDataProc.samp
         INFO["nPulseMoments"] = self.RAWDataProc.nPulseMoments
         #INFO["deadTime"] = self.RAWDataProc.deadTime
-        INFO["processed"] = "Akvo v"  + self.Akvo_VERSION + ", on "  + time.strftime("%d/%m/%Y")
+        INFO["processed"] = "Akvo v"  + VERSION + ", on "  + time.strftime("%d/%m/%Y")
         # Pulse current info
         ip = 0
         INFO["Pulses"] = {}
         self.lock("harmonic noise modelling")
         
         Harm = OrderedDict()
-        Harm["STEP"] = "Harmonic modelling"
+        Harm["STEP " + str(len(self.YamlNode.Processing))] = "Harmonic modelling"
         Harm["NF"] = str( self.ui.NHarmonicsFreqsSpin.value() ) 
         Harm["Segments"] = str( self.ui.NSegments.value() ) 
         Harm["Proc. ref."] = self.ui.harmRef.isChecked() 
         
         # Log processing 
         Adapt = OrderedDict()
-        Adapt["STEP"] = "TD noise cancellation"
-        print(Adapt) # this locks STEP in as first...
-        Adapt["n_Taps"] = str(self.ui.MTapsSpinBox.value())
-        Adapt["lambda"] = str(self.ui.adaptLambdaSpinBox.value())
-        Adapt["truncate"] = str(self.ui.adaptTruncateSpinBox.value())
-        Adapt["mu"] = str(self.ui.adaptMuSpinBox.value()) 
-        Adapt["PCA"] = str(self.ui.PCAComboBox.currentText())
-        #print(Adapt)
+        Adapt["STEP " + str(len(self.YamlNode.Processing)) ] = "TD noise cancellation"
+        #print(Adapt) # this locks STEP in as first...
+        Adapt["n_Taps"] = self.ui.MTapsSpinBox.value()
+        Adapt["lambda"] = self.ui.adaptLambdaSpinBox.value()
+        Adapt["truncate"] = self.ui.adaptTruncateSpinBox.value()
+        Adapt["mu"] = self.ui.adaptMuSpinBox.value()
+        Adapt["PCA"] = self.ui.PCAComboBox.currentText()
+        #Adapt # this locsk in the dict ordering...
+        #print(Adapt) # this locks in the dict...
         self.YamlNode.Processing.append(Adapt)
         self.Log( )
 
         self.lock("Summing data channels")
         
         Sum = OrderedDict()
-        Sum["STEP"] = "Channel sum"
+        Sum["STEP " + str(len(self.YamlNode.Processing))] = "Channel sum"
         self.YamlNode.Processing.append(Sum)
         self.Log( )
 
         
         # Log processing 
         Band = OrderedDict()
-        Band["STEP"] = "Bandpass filter"
+        Band["STEP " + str(len(self.YamlNode.Processing))] = "Bandpass filter"
         Band["central_nu"] = str(self.ui.CentralVSpinBox.value())
         Band["passband"] = str(self.ui.passBandSpinBox.value())
         Band["stopband"] = str(self.ui.stopBandSpinBox.value()) 
 
         # Log processing 
         Resample = OrderedDict() 
-        Resample["STEP"] = "Resample"
+        Resample["STEP "+ str(len(self.YamlNode.Processing))] = "Resample"
         Resample["downsample factor"] = str(self.ui.downSampleSpinBox.value())
         Resample["truncate length"] = str(self.ui.truncateSpinBox.value()) 
         self.YamlNode.Processing.append(Resample)
         
         # Log processing 
         Window = OrderedDict()
-        Window["STEP"] = "Window filter"
+        Window["STEP " + str(len(self.YamlNode.Processing))] = "Window filter"
         Window["type"] = str(self.ui.windowTypeComboBox.currentText()) 
         Window["width"] = str(self.ui.windowBandwidthSpinBox.value()) 
         Window["centre"] = str(self.ui.CentralVSpinBox.value() )

akvo/gui/mydynamicmplcanvas.py

         self.compute_initial_figure()
 
     def reAxH(self, num, shx=True, shy=True):
-        
+        fs = 10
+ 
         try:
             for ax in fig.axes:
                 self.fig.delaxes(ax)
         for n in range(num):
             if n == 0:
                 self.ax1 = self.fig.add_subplot( 1, num, 1)
-                self.ax1.tick_params(axis='both', which='major', labelsize=8)
+                self.ax1.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
                 self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='x')  
-                self.ax1.yaxis.get_offset_text().set_size(8) 
-                self.ax1.xaxis.get_offset_text().set_size(8) 
+                self.ax1.yaxis.get_offset_text().set_size(fs) 
+                self.ax1.xaxis.get_offset_text().set_size(fs) 
             if n == 1:
                 self.ax2 = self.fig.add_subplot( 1, num, 2)
-                self.ax2.tick_params(axis='both', which='major', labelsize=8)
+                self.ax2.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax2.yaxis.get_offset_text().set_size(8) 
+                self.ax2.yaxis.get_offset_text().set_size(fs) 
             if n == 2:
                 self.ax3 = self.fig.add_subplot( 1, num, 3) 
-                self.ax3.tick_params(axis='both', which='major', labelsize=8)
+                self.ax3.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax3.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax3.yaxis.get_offset_text().set_size(8) 
+                self.ax3.yaxis.get_offset_text().set_size(fs) 
             if n == 3:
                 self.ax4 = self.fig.add_subplot( 1, num, 4) 
-                self.ax4.tick_params(axis='both', which='major', labelsize=8)
+                self.ax4.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax4.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax4.yaxis.get_offset_text().set_size(8) 
+                self.ax4.yaxis.get_offset_text().set_size(fs) 
     
     def reAxH2(self, num, shx=True, shy=True):
+        fs = 10
         try:
             for ax in fig.axes:
                 self.fig.delaxes(ax)
         for n in range(num):
             if n == 0:
                 self.ax1 = self.fig.add_subplot( 2, num, 1)
-                self.ax1.tick_params(axis='both', which='major', labelsize=8)
+                self.ax1.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax1.yaxis.get_offset_text().set_size(8) 
+                self.ax1.yaxis.get_offset_text().set_size(fs) 
                 self.ax21 = self.fig.add_subplot( 2, num, num+1)
-                self.ax21.tick_params(axis='both', which='major', labelsize=8)
+                self.ax21.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax21.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax21.yaxis.get_offset_text().set_size(8) 
+                self.ax21.yaxis.get_offset_text().set_size(fs) 
             if n == 1:
                 self.ax2 = self.fig.add_subplot( 2, num, 2, sharex=self.ax1, sharey=self.ax1)
-                self.ax2.tick_params(axis='both', which='major', labelsize=8)
+                self.ax2.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax2.yaxis.get_offset_text().set_size(8) 
+                self.ax2.yaxis.get_offset_text().set_size(fs) 
                 self.ax22 = self.fig.add_subplot( 2, num, num+2, sharex=self.ax21, sharey=self.ax21)
-                self.ax22.tick_params(axis='both', which='major', labelsize=8)
+                self.ax22.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax22.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax22.yaxis.get_offset_text().set_size(8) 
+                self.ax22.yaxis.get_offset_text().set_size(fs) 
             if n == 2:
                 self.ax3 = self.fig.add_subplot( 2, num, 3, sharex=self.ax1, sharey=self.ax1)
-                self.ax3.tick_params(axis='both', which='major', labelsize=8)
+                self.ax3.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax3.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax3.yaxis.get_offset_text().set_size(8) 
+                self.ax3.yaxis.get_offset_text().set_size(fs) 
                 self.ax23 = self.fig.add_subplot( 2, num, num+3, sharex=self.ax21, sharey=self.ax21)
-                self.ax23.tick_params(axis='both', which='major', labelsize=8)
+                self.ax23.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax23.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax23.yaxis.get_offset_text().set_size(8) 
+                self.ax23.yaxis.get_offset_text().set_size(fs) 
             if n == 3:
                 self.ax4 = self.fig.add_subplot( 2, num, 4, sharex=self.ax1, sharey=self.ax1 )
-                self.ax4.tick_params(axis='both', which='major', labelsize=8)
+                self.ax4.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax4.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax4.yaxis.get_offset_text().set_size(8) 
+                self.ax4.yaxis.get_offset_text().set_size(fs) 
                 self.ax24 = self.fig.add_subplot( 2, num, num+4, sharex=self.ax21, sharey=self.ax21 )
-                self.ax24.tick_params(axis='both', which='major', labelsize=8)
+                self.ax24.tick_params(axis='both', which='major', labelsize=fs)
                 self.ax24.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
-                self.ax24.yaxis.get_offset_text().set_size(8) 
+                self.ax24.yaxis.get_offset_text().set_size(fs) 
             if n == 4:
                 self.ax5 = self.fig.add_subplot( 2, num, 5, sharex=self.ax1, sharey=self.ax1 )
                 self.ax5.tick_params(axis='both', which='major', labelsize=8)
         else:
             self.ax2 = self.fig.add_subplot(212)
 
-        self.ax1.tick_params(axis='both', which='major', labelsize=8)
-        self.ax2.tick_params(axis='both', which='major', labelsize=8)
+        self.ax1.tick_params(axis='both', which='major', labelsize=10)
+        self.ax2.tick_params(axis='both', which='major', labelsize=10)
 
         self.ax1.ticklabel_format(style='scientific', scilimits=(0,0), axis='y')  
         self.ax2.ticklabel_format(style='scientific', scilimits=(0,0), axis='y')  
 
-        self.ax1.yaxis.get_offset_text().set_size(8) 
-        self.ax2.yaxis.get_offset_text().set_size(8) 
+        self.ax1.yaxis.get_offset_text().set_size(10) 
+        self.ax2.yaxis.get_offset_text().set_size(10) 
     
     def softClear(self):
         for ax in self.fig.get_axes():
 
     def reAx3(self, shx=True, shy=True):
 
+        fs = 10
+
         try:
             self.fig.clear()
         except:
         #self.fig.set_edgecolor('red')
         #self.ax1.set_axis_bgcolor('green')
 
-        self.ax1.tick_params(axis='both', which='major', labelsize=8)
-        self.ax2.tick_params(axis='both', which='major', labelsize=8)
-        self.ax3.tick_params(axis='both', which='major', labelsize=8)
+        self.ax1.tick_params(axis='both', which='major', labelsize=fs)
+        self.ax2.tick_params(axis='both', which='major', labelsize=fs)
+        self.ax3.tick_params(axis='both', which='major', labelsize=fs)
 
         self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
         self.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
         self.ax3.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
 
-        self.ax1.yaxis.get_offset_text().set_size(8) 
-        self.ax2.yaxis.get_offset_text().set_size(8)    
-        self.ax3.yaxis.get_offset_text().set_size(8)    
+        self.ax1.yaxis.get_offset_text().set_size(fs) 
+        self.ax2.yaxis.get_offset_text().set_size(fs)    
+        self.ax3.yaxis.get_offset_text().set_size(fs)    
  
     def reAx4(self):
 

akvo/terminal/plotKernel.py

 from matplotlib.ticker import FormatStrFormatter
 import numpy as np
 import yaml
-from  lemma_yaml import *
-
+from  akvo.tressel.lemma_yaml import *
+from akvo.tressel.SlidesPlot import *
 import cmocean 
 
 def catLayers(K0):
     K = 1e9*catLayers(K0.K0)
     q = np.array(K0.PulseI.data)* (float)(K0.Taup)
 
+    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.colorbar()
+    plt.colorbar(label=r"$\left| \overline{\mathcal{V}_N}(0) \right|$ (nV)")
 
     ax1 = plt.gca()
     ax1.set_ylim( ax1.get_ylim()[1], ax1.get_ylim()[0]  )

akvo/tressel/SlidesPlot.py

 # GJI final pub specs                                                           #
 import matplotlib                                                               #
 from matplotlib import rc                                                           #
-matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{timet,amsmath,amssymb}"]  #
-rc('font',**{'family':'sans-serif','serif':['timet']})                                   #
-rc('font',**{'size':11})                                                             #
-rc('text', usetex=True)                                                             #
+
+#matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{timet,amsmath,amssymb}"]  #
+#rc('font',**{'family':'sans-serif','serif':['timet']})                                   #
+#rc('font',**{'size':11})                                                             #
+#rc('text', usetex=True)                                                             #
+
 # converts pc that GJI is defined in to inches                                      # 
 # In GEOPHYSICS \textwidth = 42pc                                               #
 #        \columnwidth = 20pc                                                    #

akvo/tressel/decay.py

 
     #method = ['trf','dogbox','lm'][method_int]
     #loss = ['linear','soft_l1','cauchy','huber'][loss_int] 
-    print ("method", method, 'loss', loss) 
+    #print ("method", method, 'loss', loss) 
     if x0=="None":
         if method == 'lm':
             x0 = np.array( [50., 0., 0., .200] ) # A0, zeta, df, T2 
         else:
             x0 = np.array( [50., 0., 0., .200] ) # A0, zeta, df, T2 
             res_lsq = least_squares(fun, x0, args=(tt, np.concatenate((X, Y))), loss=loss, f_scale=1.0,\
-                    bounds=( [5, -np.pi, -5, .001] , [1000., np.pi, 5, .800] ),
+                    bounds=( [5, -np.pi, -5, .001] , [5000., np.pi, 5, .800] ),
                     method=method 
                     )
         x = res_lsq.x 
-        print ("A0={} zeta={} df={} T2={}".format(x[0],x[1],x[2],x[3]))
+        #print ("A0={} zeta={} df={} T2={}".format(x[0],x[1],x[2],x[3]))
     else:
         res_lsq = least_squares(fun, x0, args=(tt, np.concatenate((X, Y))), loss=loss, f_scale=1.0,\
             #bounds=( [1., -np.pi, -5, .005] , [1000., np.pi, 5, .800] ),

akvo/tressel/invertTA.py

 
 def main():
 
-    if (len (sys.argv) < 3):
-        print ("python invertTA.py  K0.dat  Data.yaml")
-    print (sys.argv[1])
+    if (len (sys.argv) < 2):
+        print ("akvoQT   invertParameters.yaml")
+        exit()
+    
     with open(sys.argv[1], 'r') as stream:
         try:
             cont = (yaml.load(stream, Loader=yaml.Loader))
         except yaml.YAMLError as exc:
             print(exc)
+
     ###############################################
     # Load in data
     ###############################################
         VS[0] = np.concatenate( (VS[0], VS[iv]) )
     V = V[0]
     VS = VS[0]
-    
-    #plt.matshow(V, cmap='RdBu', vmin=-np.max(np.abs(V)), vmax=np.max(np.abs(V)))
-    #plt.title("data")
-    #plt.colorbar()
-    #plt.show()
-    #exit()    
-
-    #plt.matshow(VS, cmap='inferno', vmin=-np.max(np.abs(VS)), vmax=np.max(np.abs(VS)))
-    #plt.title("error")
-    #plt.colorbar()
 
     ###############################################
     # Load in kernels
     ############################################### 
     T2Bins = np.logspace( np.log10(cont["T2Bins"]["low"]), np.log10(cont["T2Bins"]["high"]), cont["T2Bins"]["number"], endpoint=True, base=10)  
     KQT = buildKQT(K0,tg,T2Bins)
-    #plt.matshow(KQT)
 
-    # Chan. 1    reg = 1.5   
-    # Chan. 2    reg = 1.35
-    # Chan. 4    reg = 1.95  
  
     ###############################################
     # Invert
     ############################################### 
     print("Calling inversion", flush=True)
-    inv, ibreak, errn, phim, phid, mkappa = logBarrier(KQT, np.ravel(V), T2Bins, "lcurve", MAXITER=150, sigma=np.ravel(VS), alpha=1e6, smooth="Smallest" ) #, smooth=True) # 
-                     #logBarrier(A, b, T2Bins, lambdastar, x_0=0, xr=0, alpha=10, mu1=10, mu2=10, smooth=False, MAXITER=70, fignum=1000, sigma=1, callback=None):
-    #return x, ibreak, np.sqrt(phid/len(b)), PHIM, PHID/len(b), np.argmax(kappa)
+    inv, ibreak, errn, phim, phid, mkappa = logBarrier(KQT, np.ravel(V), T2Bins, "lcurve", MAXITER=150, sigma=np.ravel(VS), alpha=1e6, smooth="Smallest" ) 
 
 
     ###############################################
 
     T2Bins = np.append( T2Bins, T2Bins[-1] + (T2Bins[-1]-T2Bins[-2]) )
     
-    print( np.shape(inv), len(ifaces)-1,cont["T2Bins"]["number"] )
     INV = np.reshape(inv, (len(ifaces)-1,cont["T2Bins"]["number"]) )
     Y,X = meshgrid( ifaces, T2Bins )
-    fig = plt.figure( figsize=(pc2in(17.0),pc2in(18.)) )
+    fig = plt.figure( figsize=(pc2in(20.0),pc2in(22.)) )
     ax1 = fig.add_axes( [.2,.15,.6,.7] )
     im = ax1.pcolor(X, Y, INV.T, cmap=cmocean.cm.tempo) #cmap='viridis')
     im.set_edgecolor('face')
     cb.ax.yaxis.set_offset_position('left')                         
     cb.update_ticks()
  
-    #ax1.set_xlabel(u"$T_2^*$ (ms)")
-    #ax1.set_ylabel(u"depth (m)$")
+    ax1.set_xlabel(u"$T_2^*$ (ms)")
+    ax1.set_ylabel(u"depth (m)")
     
     ax1.get_xaxis().set_major_formatter(FormatStrFormatter('%1.0f'))
     ax1.get_yaxis().set_major_formatter(FormatStrFormatter('%1.0f'))

akvo/tressel/logbarrier.py

 
 import matplotlib.pyplot as plt
 
+from akvo.tressel.SlidesPlot import * 
+
 def PhiB(mux, minVal, x):
     phib = mux * np.abs( np.sum(np.log( x-minVal)) )
     return phib
                 if np.sqrt(phid/len(b)) <= 1:
                     ibreak=0
 
-                plt.figure()
+                fig = plt.figure( figsize=(pc2in(20.0),pc2in(22.)) )
+                ax1 = fig.add_axes( [.2,.15,.6,.7] )
                 #plt.plot( (np.array(PHIM)),  np.log(np.array(PHID)/len(b)), '.-')
                 #plt.plot(  ((np.array(PHIM))[np.argmax(kappa)]) , np.log( (np.array(PHID)/len(b))[np.argmax(kappa)] ), '.', markersize=12)
                 #plt.axhline()
-                plt.plot( np.log(np.array(PHIM)),  np.log(np.sqrt(np.array(PHID)/len(b))), '.-')
-                plt.plot( np.log(np.array(PHIM))[np.argmax(kappa)], np.log(np.sqrt(np.array(PHID)/len(b))[np.argmax(kappa)]), '.', markersize=12)
+                lns1 = plt.plot( np.log(np.array(PHIM)),  np.log(np.sqrt(np.array(PHID)/len(b))), '.-', label="L curve")
+                lns2 = plt.plot( np.log(np.array(PHIM))[np.argmax(kappa)], np.log(np.sqrt(np.array(PHID)/len(b))[np.argmax(kappa)]), '.', markersize=12, label="$\lambda^*$")
                 ax2 = plt.twinx()
-                ax2.plot( np.log(np.array(PHIM)), kappa, color='green', label="lcurve" )
-                plt.legend()
+                lns3 = ax2.plot( np.log(np.array(PHIM)), kappa, color='orange', label="curvature" )
+
+                # Single legend 
+                lns = lns1+lns3
+                labs = [l.get_label() for l in lns]
+                ax2.legend(lns, labs, loc=0)
+
+                ax1.set_xlabel("$\phi_m$")
+                ax1.set_ylabel("$\phi_d$")
+                
+                ax2.set_ylabel("curvature")
+
                 plt.savefig('lcurve.pdf')
                 break
 

akvo/tressel/mrsurvey.py

 import matplotlib.ticker 
 from matplotlib.ticker import MaxNLocator
 
+import seaborn as sns 
+from akvo.tressel.SlidesPlot import deSpine
+
 import multiprocessing 
 import itertools 
 
         pass   
  
     def TDSmartStack(self, outlierTest, MADcutoff, canvas):
+        fs = 10 # fontsize 
         #print("Line 300 in mrsurvey")
         Stack = {}
         # align for stacking and modulate
                 ax1.yaxis.set_major_formatter(y_formatter)
 
                 ax1.plot( 1e3*self.DATADICT[pulse]["TIMES"], np.average(  SimpleStack[pulse][chan], 0 )) #, color='darkblue' )
-                ax1.set_title("Ch." + str(chan) + ": avg FID", fontsize=8)
-                ax1.set_xlabel(r"time (ms)", fontsize=8)
+                ax1.set_title("Ch." + str(chan) + ": avg FID", fontsize=fs)
+                ax1.set_xlabel(r"time (ms)", fontsize=fs)
 
                 if ichan == 0:
-                    ax1.set_ylabel(r"signal (nV)", fontsize=8)
+                    ax1.set_ylabel(r"signal (nV)", fontsize=fs)
                 else:
                     plt.setp(ax1.get_yticklabels(), visible=False)
                     plt.setp(ax1.get_yaxis().get_offset_text(), visible=False) 
                 #im2 = ax2.matshow( db, aspect='auto', cmap=cmocean.cm.ice, vmin=vvmin, vmax=vvmax)
                 if ichan == 0:
                     #ax2.set_ylabel(r"$q$ (A $\cdot$ s)", fontsize=8)
-                    ax2.set_ylabel(r"pulse index", fontsize=8)
+                    ax2.set_ylabel(r"pulse index", fontsize=10)
                     #ax1.set_ylabel(r"FID (nV)", fontsize=8)
                 else:
                     #ax2.yaxis.set_ticklabels([])
                 ichan += 1   
 
 
-        canvas.fig.subplots_adjust(hspace=.1, wspace=.05, left=.075, right=.95 )#left=None, bottom=None, right=None, top=None, wspace=None, hspace=None) 
+        canvas.fig.subplots_adjust(hspace=.35, wspace=.15, left=.15, right=.8 )#left=None, bottom=None, right=None, top=None, wspace=None, hspace=None) 
+        deSpine(ax1)
         
         #cb1 = canvas.fig.colorbar(im, ax=axes[0::2], format='%1.0e', orientation='horizontal', shrink=.35, aspect=30)
         #cb1.ax.tick_params(axis='both', which='major', labelsize=8)
         #cb1.set_label("$\mathcal{V}_N$ (nV)", fontsize=8)
 
         cb2 = canvas.fig.colorbar(im2[-1], ax=axes[1::2], format='%1.0e', orientation='horizontal', shrink=.35, aspect=30)
-        cb2.ax.tick_params(axis='both', which='major', labelsize=8)
-        cb2.set_label("$\mathcal{V}_N$ (nV)", fontsize=8)
+        cb2.ax.tick_params(axis='both', which='major', labelsize=fs)
+        cb2.set_label(r"$\left| \mathcal{V}_N \right|$ (nV)", fontsize=fs)
+                    
 
         #canvas.fig.tight_layout() 
         canvas.draw()
             canvas = mpl plotting axis      
         """
         TDPlot = True
-        
+        fs = 10       
+ 
         if plot:
             canvas.reAx2(shy=False)
-            canvas.ax1.set_ylabel(r"signal (nV)", fontsize=8)
-            canvas.ax2.set_ylabel(r"signal (nV)", fontsize=8)
+            canvas.ax1.set_ylabel(r"signal (nV)", fontsize=fs)
+            canvas.ax2.set_ylabel(r"signal (nV)", fontsize=fs)
             if TDPlot:
-                canvas.ax2.set_xlabel(r"time (s)", fontsize=8)
+                canvas.ax2.set_xlabel(r"time (s)", fontsize=fs)
             else:
-                canvas.ax2.set_xlabel(r"frequency (Hz)", fontsize=8)
+                canvas.ax2.set_xlabel(r"frequency (Hz)", fontsize=fs)
                 canvas.ax1.set_yscale('log')
                 canvas.ax2.set_yscale('log')
 
 
                     if plot:
                         if procRefs: 
-                            canvas.ax1.legend(prop={'size':6}, loc='upper right')
-                        canvas.ax2.legend(prop={'size':6}, loc='upper right')
+                            canvas.ax1.legend(prop={'size':fs}, loc='upper right')
+                            plt.setp(canvas.ax1.get_xticklabels(), visible=False)
+                        canvas.ax2.legend(prop={'size':fs}, loc='upper right')
+                        deSpine(canvas.ax1)
+                        deSpine(canvas.ax2)
+                        canvas.fig.tight_layout()
                         canvas.draw() 
                 
                 percent = (int)(1e2*((ipm+istack*self.nPulseMoments)/(self.nPulseMoments*len(self.DATADICT["stacks"])))) 
                 #ax1.plot( 1e3*self.DATADICT[pulse][chan]["FFT"]["nu"][0:len(SimpleStack[pulse][chan])], np.average(SimpleStack[pulse][chan], 0 )) #, color='darkblue' )
                 #ax1.pcolor( np.real(SimpleStack[pulse][chan]) ) #, color='darkblue' )
                 ax1.matshow( np.real(SimpleStack[pulse][chan]), aspect='auto') #, color='darkblue' )
-                ax1.set_title("Ch." + str(chan) + ": avg FID", fontsize=8)
-                ax1.set_xlabel(r"time (ms)", fontsize=8)
+                ax1.set_title("Ch." + str(chan) + ": avg FID", fontsize=10)
+                ax1.set_xlabel(r"time (ms)", fontsize=10)
 
                 if ichan == 0:
-                    ax1.set_ylabel(r"signal [nV]", fontsize=8)
+                    ax1.set_ylabel(r"signal [nV]", fontsize=10)
                 else:
                     plt.setp(ax1.get_yticklabels(), visible=False)
                     plt.setp(ax1.get_yaxis().get_offset_text(), visible=False) 
 #         cb2.set_label("$\mathcal{V}_N$ (nV)", fontsize=8)
 
         #canvas.fig.tight_layout() 
+        deSpine(ax1)
         canvas.draw()
         self.doneTrigger.emit() 
 
                     ht = signal.hilbert(xn)*np.exp(-1j*wL*self.DATADICT[pulse]["TIMES"])
                     #############################################################
                     # Quadrature signal 
-                    RE[pulse][chan][ipm,:] = np.real(ht[clip::])   
-                    IM[pulse][chan][ipm,:] = np.imag(ht[clip::])
+                    RE[pulse][chan][ipm,:] = -np.real(ht[clip::])  # negative for consistency with VC  
+                    IM[pulse][chan][ipm,:] =  np.imag(ht[clip::])
                     REmax[pulse] = max(REmax[pulse], np.max(np.real(ht[clip::])))
                     IMmax[pulse] = max(IMmax[pulse], np.max(np.imag(ht[clip::])))
                     #############################################################
 
         ###############
         # Plot on GUI #      
-        ############### 
+        ###############
+        fs = 10 
         dcmap = cmocean.cm.curl_r  #"seismic_r" #cmocean.cm.balance_r #"RdBu" #YlGn" # "coolwarm_r"  # diverging 
         canvas.reAxH2(  len(self.DATADICT[ self.DATADICT["PULSES"][0] ]["chan"] ), False, False)
         for pulse in self.DATADICT["PULSES"]:
 
             for chan in self.DATADICT[pulse]["chan"]: 
                 ax1 = axes[2*ichan  ]
-                ax2 = axes[2*ichan+1] # TODO fix hard coded number
+                ax2 = axes[2*ichan+1] 
                 if phase == 0: # Re Im 
-                    #print("plot dog", np.shape(QQ), np.shape(self.DATADICT["RE"][pulse][chan]))
-                    #print("QQ", QQ) 
                     im1 = ax1.pcolormesh( time_sp, QQ[iQ], self.DATADICT["RE"][pulse][chan][iQ], cmap=dcmap, \
-                         vmin=-self.DATADICT["REmax"][pulse] , vmax=self.DATADICT["REmax"][pulse] )
+                         vmin=-self.DATADICT["REmax"][pulse] , vmax=self.DATADICT["REmax"][pulse] , rasterized=True)
                     im2 = ax2.pcolormesh( time_sp, QQ[iQ], self.DATADICT["IM"][pulse][chan][iQ], cmap=dcmap, \
-                         vmin=-self.DATADICT["IMmax"][pulse], vmax=self.DATADICT["IMmax"][pulse]  )
+                         vmin=-self.DATADICT["IMmax"][pulse], vmax=self.DATADICT["IMmax"][pulse] , rasterized=True )
                     #im1 = ax1.matshow( self.DATADICT["RE"][pulse][chan][iQ], cmap=dcmap, aspect='auto', \
                     #     vmin=-self.DATADICT["REmax"][pulse] , vmax=self.DATADICT["REmax"][pulse] )
                     #im2 = ax2.matshow( self.DATADICT["IM"][pulse][chan][iQ], cmap=dcmap, aspect='auto', \
                     #     vmin=-self.DATADICT["REmax"][pulse] , vmax=self.DATADICT["REmax"][pulse] )
                 if phase == 1: # Amp phase
                     im1 = ax1.pcolormesh( time_sp, QQ[iQ], self.DATADICT["CA"][pulse][chan][iQ], cmap=dcmap, \
-                         vmin=-self.DATADICT["CAmax"][pulse] , vmax=self.DATADICT["CAmax"][pulse]  )
+                         vmin=-self.DATADICT["CAmax"][pulse] , vmax=self.DATADICT["CAmax"][pulse], rasterized=True  )
                     #im2 = ax2.pcolormesh( time_sp, QQ, self.DATADICT["IP"][pulse][chan], cmap=cmocean.cm.balance, rasterized=True,\
                     im2 = ax2.pcolormesh( time_sp, QQ[iQ], self.DATADICT["IP"][pulse][chan][iQ], cmap=cmocean.cm.delta, \
-                         vmin=-np.pi, vmax=np.pi)
+                         vmin=-np.pi, vmax=np.pi, rasterized=True)
                 if phase == 2: # CA NR
                     im1 = ax1.pcolormesh( time_sp, QQ[iQ], self.DATADICT["CA"][pulse][chan][iQ], cmap=dcmap, \
-                         vmin=-self.DATADICT["CAmax"][pulse] , vmax=self.DATADICT["CAmax"][pulse] )
+                         vmin=-self.DATADICT["CAmax"][pulse] , vmax=self.DATADICT["CAmax"][pulse], rasterized=True )
                     im2 = ax2.pcolormesh( time_sp, QQ[iQ], self.DATADICT["NR"][pulse][chan][iQ], cmap=dcmap, \
-                         vmin=-self.DATADICT["NRmax"][pulse] , vmax=self.DATADICT["NRmax"][pulse] )
+                         vmin=-self.DATADICT["NRmax"][pulse] , vmax=self.DATADICT["NRmax"][pulse], rasterized=True )
 #                     cb2 = canvas.fig.colorbar(im2, ax=ax2, format='%1.0e')
 #                     cb2.set_label("Noise residual (nV)", fontsize=8)
 #                     cb2.ax.tick_params(axis='both', which='major', labelsize=8)
                 self.progressTrigger.emit(percent)
                 
                 if ichan == 0:
-                    ax1.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=8)
-                    ax2.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=8)
+                    ax1.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=fs)
+                    ax2.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=fs)
                 else:
                     #ax2.yaxis.set_ticklabels([])
                     #ax1.yaxis.set_ticklabels([])
             ax2.set_xlim( np.min(time_sp), np.max(time_sp) )
 
             #ax2.set_xlabel(r"Time since end of pulse  (ms)", fontsize=8)
-            ax2.set_xlabel(r"Time (ms)", fontsize=8)
+            ax2.set_xlabel(r"time (ms)", fontsize=fs)
+        
+        #canvas.fig.subplots_adjust(hspace=.15, wspace=.05, left=.15, right=.85, bottom=.15, top=.9 )#left=None, bottom=None, right=None, top=None, wspace=None, hspace=None) 
+        canvas.fig.subplots_adjust(hspace=.15, wspace=.05, left=.15, right=.90, bottom=.15, top=.95 )#left=None, bottom=None, right=None, top=None, wspace=None, hspace=None) 
         
-        canvas.fig.subplots_adjust(hspace=.15, wspace=.05, left=.075, right=.95, bottom=.1, top=.95 )#left=None, bottom=None, right=None, top=None, wspace=None, hspace=None) 
         tick_locator = MaxNLocator(nbins=3)
 
-        cb1 = canvas.fig.colorbar(im1, ax=axes[0::2], format='%1.0e', orientation='horizontal', shrink=.35, aspect=30)
-        cb1.ax.tick_params(axis='both', which='major', labelsize=8)
-        cb1.set_label("$\mathcal{V}_N$ (nV)", fontsize=8)
+        cb1 = canvas.fig.colorbar(im1, ax=axes[0::2], format='%1.0f', orientation='vertical')
+        #cb1 = canvas.fig.colorbar(im1, ax=axes[0::2], format='%1.0f', orientation='horizontal', shrink=.35, aspect=30, pad=.4)
+        cb1.ax.tick_params(axis='both', which='major', labelsize=fs)
+
         cb1.locator = tick_locator
         cb1.update_ticks()
 
         tick_locator2 = MaxNLocator(nbins=3)
-        cb2 = canvas.fig.colorbar(im2, ax=axes[1::2], format='%1.0e', orientation='horizontal', shrink=.35, aspect=30, pad=.2)
-        cb2.ax.tick_params(axis='both', which='major', labelsize=8)
-        if phase == 1: # Amp phase
-            cb2.set_label(r"$\angle \mathcal{V}_N$", fontsize=8)
+        cb2 = canvas.fig.colorbar(im2, ax=axes[1::2], format='%1.0f', orientation='vertical')
+        #cb2 = canvas.fig.colorbar(im2, ax=axes[1::2], format='%1.0f', orientation='horizontal', shrink=.35, aspect=30, pad=.4)
+        cb2.ax.tick_params(axis='both', which='major', labelsize=fs)
+
+        if phase == 0: # Re Im 
+            cb1.set_label(r"$\mathrm{Re} \left( \mathcal{V}_N \right)$ (nV)", fontsize=fs)
+            cb2.set_label(r"$\mathrm{Im} \left( \mathcal{V}_N \right)$ (nV)", fontsize=fs)
+        elif phase == 1: # Amp phase
+            cb1.set_label(r"$\left| \mathcal{V}_N \right|$ (nV)", fontsize=fs)
+            cb2.set_label(r"$\angle \mathcal{V}_N$", fontsize=fs)
         else:
-            cb2.set_label("$\mathcal{V}_N$ (nV)", fontsize=8)
+            cb1.set_label(r"$\left| \mathcal{V}_N \right|$ (nV)", fontsize=fs)
+            cb2.set_label(r"noise (nV)", fontsize=fs)
 
 
         cb2.locator = tick_locator2
         cb2.update_ticks()
 
+        #canvas.fig.tight_layout()
         canvas.draw()
         self.doneTrigger.emit() 
 
     def plotGateIntegrate( self, gpd, clip, phase, canvas ):
         """ Plot the gate integration 
         """
-        
+       
+        fs = 10 
+ 
         canvas.reAxH2(  len(self.DATADICT[ self.DATADICT["PULSES"][0] ]["chan"] ), False, False)
         axes = canvas.fig.axes
         #cmap = cmocean.cm.balance_r 
                 ax2.xaxis.set_major_formatter(formatter) #matplotlib.ticker.FormatStrFormatter('%d.1'))
                 
                 if ichan == 0:
-                    ax1.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=8)
+                    ax1.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=fs)
                     if phase == 2:
-                        ax2.set_ylabel(r"noise est. (nV)", fontsize=8)
+                        ax2.set_ylabel(r"noise est. (nV)", fontsize=fs)
                     else:
-                        ax2.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=8)
+                        ax2.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=fs)
                 else:
                     plt.setp(ax1.get_yticklabels(), visible=False)
                     plt.setp(ax2.get_yticklabels(), visible=False)
         
-                ax2.set_xlabel(r"$t-\tau_p$  (ms)", fontsize=8)
+                ax2.set_xlabel(r"$t-\tau_p$  (ms)", fontsize=fs)
                 ichan += 1 
 
         #canvas.fig.subplots_adjust(hspace=.1, wspace=.05, left=.075, right=.925 )#left=None, bottom=None, right=None, top=None, wspace=None, hspace=None) 
         #canvas.fig.tight_layout()
         #canvas.draw()
-        canvas.fig.subplots_adjust(hspace=.15, wspace=.05, left=.075, right=.95, bottom=.1, top=.95 )#left=None, bottom=None, right=None, top=None, wspace=None, hspace=None) 
+        canvas.fig.subplots_adjust(hspace=.15, wspace=.05, left=.15, right=.9, bottom=.1, top=.9 )#left=None, bottom=None, right=None, top=None, wspace=None, hspace=None) 
         tick_locator = MaxNLocator(nbins=5)
 
-        cb1 = canvas.fig.colorbar(im1, ax=axes[0::2], format='%1.0e', orientation='horizontal', shrink=.35, aspect=30)
-        cb1.ax.tick_params(axis='both', which='major', labelsize=8)
-        cb1.set_label("$\mathcal{V}_N$ (nV)", fontsize=8)
+        cb1 = canvas.fig.colorbar(im1, ax=axes[0::2], format='%1.0f', orientation='horizontal', shrink=.35, aspect=30)
+        cb1.ax.tick_params(axis='both', which='major', labelsize=fs)
+        cb1.set_label("$\mathcal{V}_N$ (nV)", fontsize=fs)
         #cb1.locator = tick_locator
         #cb1.update_ticks()
 
         if phase != 2:
-            cb2 = canvas.fig.colorbar(im2, ax=axes[1::2], format='%1.0e', orientation='horizontal', shrink=.35, aspect=30, pad=.2)
-            cb2.ax.tick_params(axis='both', which='major', labelsize=8)
-            cb2.set_label("$\mathcal{V}_N$ (nV)", fontsize=8)
+            cb2 = canvas.fig.colorbar(im2, ax=axes[1::2], format='%1.0f', orientation='horizontal', shrink=.35, aspect=30, pad=.2)
+            cb2.ax.tick_params(axis='both', which='major', labelsize=fs)
+            cb2.set_label("$\mathcal{V}_N$ (nV)", fontsize=fs)
 
             cb2.locator = tick_locator
             cb2.update_ticks()
                     self.DATADICT[pulse]["qeff"][ipm][istack] = qeff
                     self.DATADICT[pulse]["q_nu"][ipm][istack] = v
                     iistack += 1
-
-                canvas.ax1.set_xlabel("time (ms)", fontsize=8)
-                canvas.ax1.set_ylabel("current (A)", fontsize=8)
-                canvas.draw()
-
+                #canvas.draw()
                         
                 percent = int(1e2* (float)((istack)+ipm*self.DATADICT["nPulseMoments"]) / 
                                    (float)(len(self.DATADICT["PULSES"])*self.DATADICT["nPulseMoments"]*nstack))
                 self.progressTrigger.emit(percent)
 
-            canvas.draw()
-
+            canvas.ax1.set_xlabel("time (ms)", fontsize=10)
+            canvas.ax1.set_ylabel("current (A)", fontsize=10)
+            #canvas.draw()
 
         self.plotQeffNu(cv, canvas.ax2)
+
+        deSpine(canvas.ax1)        
+        deSpine(canvas.ax2)        
+
+        canvas.fig.tight_layout()
         canvas.draw()
         self.doneTrigger.emit() 
 
                     self.progressTrigger.emit(percent)
                     istack += 1
             iFID += 1
-        ax.set_xlabel(r"pulse moment index", fontsize=8)
-        ax.set_ylabel(r"$q_{eff}$ [A$\cdot$sec]", fontsize=8)
+        ax.set_xlabel(r"pulse moment index", fontsize=10)
+        ax.set_ylabel(r"$q_{eff}$ (A$\cdot$sec)", fontsize=10)
         ax.set_yscale('log')
         ax.set_xlim(0, ax.get_xlim()[1])
-        ax.legend(loc='upper right', scatterpoints = 1, prop={'size':6})
+        ax.legend(loc='upper right', scatterpoints = 1, prop={'size':10})
 
     def enableDSP(self):
         self.enableDSPTrigger.emit() 
                             self.DATADICT[pulse][ichan][ipm][istack] = e[::-1]
                            
      
-                        canvas.ax1.plot( H[pulse][ichan].reshape(-1, len(RX)) ) # , label="taps") 
+                        #canvas.ax1.plot( H[pulse][ichan].reshape(-1, len(RX)) ) # , label="taps") 
+                        canvas.ax1.plot( H[pulse][ichan][::-1].reshape(M, len(RX), order='F' ) ) #.reshape(-1, len(RX)) ) # , label="taps") 
 
-                        canvas.ax2.legend(prop={'size':6}, loc='upper right')
+                        canvas.ax2.legend(prop={'size':10}, 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)
+                        canvas.ax2.set_xlabel(r"time (s)", fontsize=10)
+                        canvas.ax2.set_ylabel(r"signal (nV)", fontsize=10)
+
+                        canvas.ax1.set_xlabel(r"filter tap index", fontsize=10)
+                        canvas.ax1.set_ylabel(r"tap amplitude", fontsize=10)
 
-                        canvas.ax1.set_xlabel(r"filter index", fontsize=8)
-                        canvas.ax1.set_ylabel(r"scale factor", fontsize=8)
+                    canvas.fig.tight_layout()
+                    deSpine(canvas.ax1)
+                    deSpine(canvas.ax2)
 
                     canvas.draw()
 
         """
         
         if plot:
+            fs = 10
             canvas.reAx2()
-            canvas.ax1.set_ylabel(r"signal [nV]", fontsize=8)
-            canvas.ax2.set_xlabel(r"time [s]", fontsize=8)
-            canvas.ax2.set_ylabel(r"signal [nV]", fontsize=8)
+            canvas.ax1.set_ylabel(r"signal (nV)", fontsize=fs)
+            canvas.ax2.set_xlabel(r"time (s)", fontsize=fs)
+            canvas.ax2.set_ylabel(r"signal (nV)", fontsize=fs)
 
         self.samp /= dec
         self.dt   = 1./self.samp       
                         for ichan in self.DATADICT[pulse]["rchan"]:
                             canvas.ax1.plot( RSTIMES, 1e9*self.DATADICT[pulse][ichan][ipm][istack], \
                                 label = pulse + " ipm=" + str(ipm) + " istack=" + str(istack) + " ichan="  + str(ichan))
-                        canvas.ax1.legend(prop={'size':6}, loc='upper right')
-                        canvas.ax2.legend(prop={'size':6}, loc='upper right')
+                        canvas.ax1.legend(prop={'size':fs}, loc='upper right')
+                        canvas.ax2.legend(prop={'size':fs}, loc='upper right')
+                   
+                        deSpine( canvas.ax1 ) 
+                        deSpine( canvas.ax2 ) 
+                        plt.setp(canvas.ax1.get_xticklabels(), visible=False)
+                        canvas.fig.tight_layout()
                         canvas.draw() 
+
                 percent = (int)(1e2*((float)(iFID*self.DATADICT["nPulseMoments"]+(ipm))/( len(self.DATADICT["PULSES"])*self.nPulseMoments)))
                 self.progressTrigger.emit(percent)
             iFID += 1  
                     for ichan in rchan:
                         canvas.ax2.plot(self.DATADICT["Pulse 1"]["TIMES"], self.DATADICT["Pulse 1"][ichan][ipm][istack], label="Pulse 1 FID ref ch. "+str(ichan)) #, color='blue')
 
-                    canvas.ax3.legend(prop={'size':6}, loc='upper right')
-                    canvas.ax2.legend(prop={'size':6}, loc='upper right')
+                    # reference axis
+                    canvas.ax2.tick_params(axis='both', which='major', labelsize=10)
+                    canvas.ax2.tick_params(axis='both', which='minor', labelsize=10)
+                    #canvas.ax2.xaxis.set_ticklabels([])
+                    plt.setp(canvas.ax2.get_xticklabels(), visible=False)
+                    canvas.ax2.legend(prop={'size':10}, loc='upper right')
+                    canvas.ax2.set_title("stack "+str(istack)+" pulse index " + str(ipm), fontsize=10)
+                    canvas.ax2.set_ylabel("RAW signal [V]", fontsize=10)
 
-                    canvas.ax1.set_ylabel("Current [A]", fontsize=8) 
+
+                    canvas.ax1.set_ylabel("Current (A)", fontsize=10) 
                     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.ax1.set_xlabel("time (s)", fontsize=10)
 
+                    canvas.ax3.legend(prop={'size':10}, loc='upper right')
+                    canvas.ax3.set_ylabel("RAW signal [V]", fontsize=10)
+                    
+                    canvas.fig.tight_layout()
                     canvas.draw()
 
             percent = (int) (1e2*((float)((iistack*self.nPulseMoments+ipm+1))  / (len(procStacks)*self.nPulseMoments)))

setup.py

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