fix for viridis in newest matplotlib

akvo/gui/akvoGUI.py

         INFO = {}
         INFO["headerstr"] = str(self.headerstr)
         INFO["pulseType"] = self.RAWDataProc.pulseType
-        INFO["transFreq"] = self.RAWDataProc.transFreq.tolist()
-        INFO["pulseLength"] = self.RAWDataProc.pulseLength.tolist()
-        INFO["TuneCapacitance"] = self.RAWDataProc.TuneCapacitance.tolist()
+        INFO["transFreq"] = np.array(self.RAWDataProc.transFreq).tolist()  # numpy is for MIDI datasets
+        INFO["pulseLength"] = np.array(self.RAWDataProc.pulseLength).tolist()
+        INFO["TuneCapacitance"] = np.array(self.RAWDataProc.TuneCapacitance).tolist()
         #INFO["samp"] = self.RAWDataProc.samp
         INFO["nPulseMoments"] = self.RAWDataProc.nPulseMoments
         #INFO["deadTime"] = self.RAWDataProc.deadTime
             qq = []
             qv = []
             for ipm in range(self.RAWDataProc.DATADICT["nPulseMoments"]):     
+            #for ipm in self.pulseMoments: 
                 #for istack in self.RAWDataProc.DATADICT["stacks"]:
                 #    print ("stack q", self.RAWDataProc.DATADICT[pulse]["Q"][ipm,istack-1])
                 qq.append(np.mean(    self.RAWDataProc.DATADICT[pulse]["Q"][ipm,:]) )
                     #INFO["Gated"][pulse]["Chan. " + str(ichan)]["STD"] =  VectorXr(   np.std(self.RAWDataProc.GATED[ichan]["NR"], axis=0) )
                     INFO["Gated"][pulse]["Chan. " + str(ichan)]["STD"] = VectorXr( np.average(self.RAWDataProc.GATED[ichan]["BN"], axis=0) )
                     for ipm in range(self.RAWDataProc.DATADICT["nPulseMoments"]):     
+                    #for ipm in self.pulseMoments: 
                         INFO["Gated"][pulse]["Chan. " + str(ichan)]["Q-"+str(ipm) + " CA"] = VectorXr(self.RAWDataProc.GATED[ichan]["CA"][ipm])   
                         INFO["Gated"][pulse]["Chan. " + str(ichan)]["Q-"+str(ipm) + " RE"] = VectorXr(self.RAWDataProc.GATED[ichan]["RE"][ipm])   
                         INFO["Gated"][pulse]["Chan. " + str(ichan)]["Q-"+str(ipm) + " IM"] = VectorXr(self.RAWDataProc.GATED[ichan]["IM"][ipm])   
             QtWidgets.QMessageBox.critical(self, 'Error', err_msg) 
             return
 
+        ######################
+        # Qs
+        #####################
+        print("text",  self.ui.QLineEdit.text()) 
+        if  self.ui.QLineEdit.text() == "":
+            self.pulseMoments = [-1]  
+            print("Setting pulse moments to [-1]") 
+        else:
+            try:
+                self.pulseMoments = np.array(eval(str("np.r_["+self.ui.QLineEdit.text())+"]"))
+            except:
+                err_msg = "You need to set your pulse moments correctly.\n" + \
+                      "This should be a Python Numpy interpretable list\n" + \
+                      "of stack indices. For example 1:24 or 1:4,8:24"
+                QtWidgets.QMessageBox.critical(self, 'Error', err_msg) 
+
+        ###################
         # Data Channels
-        #Chan = np.arange(0,9,1)
+        ###################
         try:
             self.dataChan = np.array(eval(str("np.r_["+self.ui.dataChanLineEdit.text())+"]"))
         except:
             reply = QtWidgets.QMessageBox.critical(self, 'Error', 
                 err_msg) #, QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
             return
+
         #############################
         # Reference Channels
         # TODO make sure no overlap between data and ref channels
         self.procThread = thread.start_new_thread(self.RAWDataProc.loadMIDI2, \
                 (str(self.headerstr), self.procStacks, self.dataChan, self.refChan, \
                  str(self.ui.FIDProcComboBox.currentText()), self.ui.mplwidget, \
-                1e-3 * self.ui.DeadTimeSpinBox.value( ), self.ui.plotImportCheckBox.isChecked() )) #, self)) 
+                1e-3 * self.ui.DeadTimeSpinBox.value( ), self.pulseMoments,
+                self.ui.plotImportCheckBox.isChecked() )) #, self)) 
 
         self.YamlNode.Import["MIDI Header"] = self.headerstr
         self.YamlNode.Import["opened"] = datetime.datetime.now().isoformat() 
             QtWidgets.QMessageBox.critical(self, 'Error', err_msg) 
             return
 
+        # Qs
+        if  self.ui.QLineEdit.text() == "Optional":
+            self.pulseMoments = [-1] 
+        else:
+            try:
+                self.pulseMoments = np.array(eval(str("np.r_["+self.ui.QLineEdit.text())+"]"))
+            except:
+                err_msg = "You need to set your pulse moments correctly.\n" + \
+                      "This should be a Python Numpy interpretable list\n" + \
+                      "of stack indices. For example 1:24 or 1:4,8:24"
+                QtWidgets.QMessageBox.critical(self, 'Error', err_msg) 
+
         # Data Channels
         #Chan = np.arange(0,9,1)
         try:
             self.procThread = thread.start_new_thread(self.RAWDataProc.loadFIDData, \
                 (str(self.headerstr), self.procStacks, self.dataChan, self.refChan, \
                  str(self.ui.FIDProcComboBox.currentText()), self.ui.mplwidget, \
-                1e-3 * self.ui.DeadTimeSpinBox.value( ), self.ui.plotImportCheckBox.isChecked() )) #, self)) 
+                1e-3 * self.ui.DeadTimeSpinBox.value( ), 
+                self.ui.plotImportCheckBox.isChecked() )) #, self)) 
         elif self.RAWDataProc.pulseType == "4PhaseT1":
             self.procThread = thread.start_new_thread(self.RAWDataProc.load4PhaseT1Data, \
                 (str(self.headerstr), self.procStacks, self.dataChan, self.refChan, \

akvo/gui/main.ui

          <x>0</x>
          <y>0</y>
          <width>537</width>
-         <height>982</height>
+         <height>1025</height>
         </rect>
        </property>
        <property name="sizePolicy">
                <string>Input parameters</string>
               </property>
               <layout class="QGridLayout" name="gridLayout_4">
-               <item row="0" column="0">
-                <widget class="QLabel" name="label">
-                 <property name="toolTip">
-                  <string/>
-                 </property>
-                 <property name="statusTip">
-                  <string comment="yo" extracomment="jldafjlk   kldajflj  adlkfjl"/>
-                 </property>
+               <item row="1" column="0">
+                <widget class="QLabel" name="label_23">
                  <property name="text">
-                  <string>Stacks</string>
+                  <string>Data Chs.</string>
                  </property>
                 </widget>
                </item>
-               <item row="0" column="1">
-                <widget class="QLineEdit" name="stacksLineEdit">
+               <item row="3" column="1">
+                <widget class="QComboBox" name="FIDProcComboBox">
                  <property name="maximumSize">
                   <size>
                    <width>16777215</width>
                   </size>
                  </property>
                  <property name="toolTip">
-                  <string notr="true">&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the stacks that you would like processed.&lt;/p&gt;&lt;p&gt;This must be a valid set of numpy array indices. Remember that Python uses non end-inclusive indexing. &lt;/p&gt;&lt;p&gt;So things like [1:24] will include stacks 1-23&lt;/p&gt;&lt;p&gt;Furthermore [1:8,12:24] will include stacks 1-7 and 12:23. Any list of valid indices will be accepted, but they must be comma seperated. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+                  <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;For T1 or CPMG pulses, which pulse(s) would you like to process. Note that for very short delay T1 pulses, the first pulse may be disabled. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
-                 <property name="placeholderText">
-                  <string>required</string>
+                </widget>
+               </item>
+               <item row="3" column="3">
+                <widget class="QPushButton" name="loadDataPushButton">
+                 <property name="enabled">
+                  <bool>false</bool>
+                 </property>
+                 <property name="styleSheet">
+                  <string notr="true">#loadDataPushButton {
+    background: green;
+}
+
+#loadDataPushButton:disabled {
+    background: black;
+}</string>
+                 </property>
+                 <property name="text">
+                  <string>Load Data</string>
                  </property>
                 </widget>
                </item>
-               <item row="0" column="2">
-                <widget class="QLabel" name="label_24">
+               <item row="3" column="0">
+                <widget class="QLabel" name="label_29">
                  <property name="text">
-                  <string>Dead time [ms]</string>
+                  <string>Process FID</string>
                  </property>
                 </widget>
                </item>
-               <item row="0" column="3">
-                <widget class="QDoubleSpinBox" name="DeadTimeSpinBox">
+               <item row="1" column="1">
+                <widget class="QLineEdit" name="dataChanLineEdit">
                  <property name="maximumSize">
                   <size>
                    <width>16777215</width>
                   </size>
                  </property>
                  <property name="toolTip">
-                  <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;This is the instrument dead time that is used. You may remove additonal or less dead time as an option. By default Akvo uses the recommended instrument dead times.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-                 </property>
-                 <property name="minimum">
-                  <double>0.500000000000000</double>
-                 </property>
-                 <property name="singleStep">
-                  <double>0.500000000000000</double>
+                  <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the data channels that you would like processed.&lt;/p&gt;&lt;p&gt;This must be a valid set of numpy array indices. Remember that Python uses non end-inclusive indexing. &lt;/p&gt;&lt;p&gt;So things like [1:3] will use channels 1 and 2&lt;/p&gt;&lt;p&gt;Any list of valid indices will be accepted, but they must be comma seperated. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
-                 <property name="value">
-                  <double>5.000000000000000</double>
+                 <property name="placeholderText">
+                  <string>required</string>
                  </property>
                 </widget>
                </item>
-               <item row="1" column="0">
-                <widget class="QLabel" name="label_23">
+               <item row="3" column="2">
+                <widget class="QCheckBox" name="plotImportCheckBox">
+                 <property name="enabled">
+                  <bool>false</bool>
+                 </property>
                  <property name="text">
-                  <string>Data Chs.</string>
+                  <string> Plot RAW</string>
+                 </property>
+                 <property name="checked">
+                  <bool>true</bool>
                  </property>
                 </widget>
                </item>
-               <item row="1" column="1">
-                <widget class="QLineEdit" name="dataChanLineEdit">
+               <item row="0" column="1">
+                <widget class="QLineEdit" name="stacksLineEdit">
                  <property name="maximumSize">
                   <size>
                    <width>16777215</width>
                   </size>
                  </property>
                  <property name="toolTip">
-                  <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the data channels that you would like processed.&lt;/p&gt;&lt;p&gt;This must be a valid set of numpy array indices. Remember that Python uses non end-inclusive indexing. &lt;/p&gt;&lt;p&gt;So things like [1:3] will use channels 1 and 2&lt;/p&gt;&lt;p&gt;Any list of valid indices will be accepted, but they must be comma seperated. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+                  <string notr="true">&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the stacks that you would like processed.&lt;/p&gt;&lt;p&gt;This must be a valid set of numpy array indices. Remember that Python uses non end-inclusive indexing. &lt;/p&gt;&lt;p&gt;So things like [1:24] will include stacks 1-23&lt;/p&gt;&lt;p&gt;Furthermore [1:8,12:24] will include stacks 1-7 and 12:23. Any list of valid indices will be accepted, but they must be comma seperated. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
                  <property name="placeholderText">
                   <string>required</string>
                  </property>
                 </widget>
                </item>
-               <item row="2" column="0">
-                <widget class="QLabel" name="label_29">
-                 <property name="text">
-                  <string>Process FID</string>
-                 </property>
-                </widget>
-               </item>
-               <item row="2" column="1">
-                <widget class="QComboBox" name="FIDProcComboBox">
+               <item row="0" column="3">
+                <widget class="QDoubleSpinBox" name="DeadTimeSpinBox">
                  <property name="maximumSize">
                   <size>
                    <width>16777215</width>
                   </size>
                  </property>
                  <property name="toolTip">
-                  <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;For T1 or CPMG pulses, which pulse(s) would you like to process. Note that for very short delay T1 pulses, the first pulse may be disabled. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+                  <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;This is the instrument dead time that is used. You may remove additonal or less dead time as an option. By default Akvo uses the recommended instrument dead times.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+                 </property>
+                 <property name="minimum">
+                  <double>0.500000000000000</double>
+                 </property>
+                 <property name="singleStep">
+                  <double>0.500000000000000</double>
+                 </property>
+                 <property name="value">
+                  <double>5.000000000000000</double>
                  </property>
                 </widget>
                </item>
-               <item row="2" column="2">
-                <widget class="QCheckBox" name="plotImportCheckBox">
-                 <property name="enabled">
-                  <bool>false</bool>
+               <item row="0" column="0">
+                <widget class="QLabel" name="label">
+                 <property name="toolTip">
+                  <string/>
+                 </property>
+                 <property name="statusTip">
+                  <string comment="yo" extracomment="jldafjlk   kldajflj  adlkfjl"/>
                  </property>
                  <property name="text">
-                  <string> Plot RAW</string>
+                  <string>Stacks</string>
                  </property>
-                 <property name="checked">
-                  <bool>true</bool>
+                </widget>
+               </item>
+               <item row="0" column="2">
+                <widget class="QLabel" name="label_24">
+                 <property name="text">
+                  <string>Dead time [ms]</string>
                  </property>
                 </widget>
                </item>
-               <item row="2" column="3">
-                <widget class="QPushButton" name="loadDataPushButton">
-                 <property name="enabled">
-                  <bool>false</bool>
+               <item row="2" column="1">
+                <widget class="QLineEdit" name="QLineEdit">
+                 <property name="toolTip">
+                  <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;If you would like to only process certain pulse moments you can specify the q indices to process. This also uses python conventions, so for instance 0:5,9:14 would process indices 0,1,2,3,4,9,10,11,12,13,14. &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
-                 <property name="styleSheet">
-                  <string notr="true">#loadDataPushButton {
-    background: green;
-}
-
-#loadDataPushButton:disabled {
-    background: black;
-}</string>
+                 <property name="text">
+                  <string/>
+                 </property>
+                 <property name="placeholderText">
+                  <string>optional</string>
                  </property>
+                </widget>
+               </item>
+               <item row="2" column="0">
+                <widget class="QLabel" name="label_87">
                  <property name="text">
-                  <string>Load Data</string>
+                  <string>Q indices</string>
                  </property>
                 </widget>
                </item>
               <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/terminal/plotyaml.py

 
     #plt.matshow(RE)
     #plt.matshow(IM)
-    plt.savefig("data.pdf")
-    plt.show()
+    plt.savefig("data.pgf")
+    plt.savefig("data.png", dpi=300)
+    #plt.show()
 
 if __name__ == "__main__":
     akvo = loadAkvoData( sys.argv[1] ) #, "Chan. 1")

akvo/tressel/calcAkvoKernel.py

         print( str(kparams["Lspacing"]) )
         exit()
 
-    iface = np.cumsum(thick)
+    print( np.array(kparams["origin_d"]) )
+    print( np.cumsum(thick)[0:-1] ) 
+    iface = np.concatenate( (np.array( [kparams["origin_d"]] ), kparams["origin_d"]+np.cumsum(thick)[0:-1]) )
     Kern.SetDepthLayerInterfaces(iface)
     #Kern.SetDepthLayerInterfaces(np.geomspace(1, 110, num=40))
     #Kern.SetDepthLayerInterfaces(np.linspace(1, 110, num=50))

akvo/tressel/decay.py

         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] , [5000., np.pi, 5, .800] ),
+                    bounds=( [1, -np.pi, -10, .01] , [500., np.pi, 10, .800] ),
                     method=method 
                     )
         x = res_lsq.x 

akvo/tressel/invertTA.py

             cont = (yaml.load(stream, Loader=yaml.Loader))
         except yaml.YAMLError as exc:
             print(exc)
+            exit(1)
 
     ###############################################
     # Load in data
     # Linear Inversion 
     ############################################### 
     print("Calling inversion", flush=True)
-    inv, ibreak, errn, phim, phid, mkappa, Wd, Wm, alphastar = logBarrier(KQT, np.ravel(V), T2Bins, "lcurve", MAXITER=150, sigma=np.ravel(VS), alpha=1e6, smooth="Smallest" ) 
+    inv, ibreak, errn, phim, phid, mkappa, Wd, Wm, alphastar = logBarrier(KQT, np.ravel(V), T2Bins, "lcurve", MAXITER=150, sigma=np.ravel(VS), alpha=1e7, smooth="Smallest" ) 
 
 
     ################################
                 PREc = np.reshape( prec, np.shape(V)  )
                 print("PHID linear=", errn, "PHID nonlinear=", phidc/len(np.ravel(V)))
             else:
+                nonLinearRefinement = False
+                print("Non-linear inversion failed, results will not be shown")
                 break
 
             if phidc_old - phidc/len(np.ravel(V)) < 0.005:
     # Only show ticks on the left and bottom spines
     ax.yaxis.set_ticks_position('left')
     ax.xaxis.set_ticks_position('bottom')   
+    plt.legend()  
  
     plt.savefig("akvoInversionWC.pdf")
-    plt.legend()  
+
     
     fr = pd.DataFrame( INV, columns=T2Bins ) #[0:-1] )
     fr.insert(0, "layer top", ifaces[0:-1] )

akvo/tressel/logbarrier.py

         #print("inversion progress", i, alpha, np.sqrt(phid/len(b)), phim, flush=True)      
         #print ("{:<8} {:<15} {:<10} {:<10}".format(i, alpha, np.sqrt(phid/len(b)), phim), flush=True) 
         
-        if i < 4:        
+        if i <= 4:        
             print ("{:^5} {:>15.4f} {:>15.4f} {:>15.4f} {:>15.4f}".format(i, alpha, np.sqrt(phid/len(b)), phim, tphi ), flush=True) 
 
 #         if np.sqrt(phid/len(b)) < 0.97: 

akvo/tressel/mrsurvey.py

 import akvo.tressel.harmonic as harmonic
 
 import cmocean # colormaps for geophysical data 
-plt.register_cmap(name='viridis', cmap=cmaps.viridis)
-plt.register_cmap(name='inferno', cmap=cmaps.inferno)
-plt.register_cmap(name='inferno_r', cmap=cmaps.inferno_r)
-
-plt.register_cmap(name='magma', cmap=cmaps.magma)
-plt.register_cmap(name='magma_r', cmap=cmaps.magma_r)
+# not needed with latest matplotlib 
+#plt.register_cmap(name='viridis', cmap=cmaps.viridis)
+#plt.register_cmap(name='inferno', cmap=cmaps.inferno)
+#plt.register_cmap(name='inferno_r', cmap=cmaps.inferno_r)
+#plt.register_cmap(name='magma', cmap=cmaps.magma)
+#plt.register_cmap(name='magma_r', cmap=cmaps.magma_r)
 
 
 def xxloadGMRBinaryFID( rawfname, info ):
                     IP[pulse][chan][ipm,:] = np.angle(ht)[clip::]
                     #############################################################
                     # Rotated amplitude
-                    #if ipm != 0:
-                    #    [success, E0, df, phi, T2] = decay.quadratureDetect2( ht.real, ht.imag, self.DATADICT[pulse]["TIMES"], (E0,phi,df,T2))
+                    if ipm != 0:
+                        [success, E0, df, phi, T2] = decay.quadratureDetect2( ht.real, ht.imag, self.DATADICT[pulse]["TIMES"], method, loss, (E0,phi,df,T2))
                     #[success, E0, df, phi, T2] = decay.quadratureDetect( ht.real, ht.imag, self.DATADICT[pulse]["TIMES"] )
-                    #else:
-                    [success, E0, df, phi, T2] = decay.quadratureDetect2( ht.real, ht.imag, self.DATADICT[pulse]["TIMES"], method, loss)
+                    else:
+                        [success, E0, df, phi, T2] = decay.quadratureDetect2( ht.real, ht.imag, self.DATADICT[pulse]["TIMES"], method, loss)
                     #[success, E0, df, phi, T2] = decay.quadratureDetect2( ht.real, ht.imag, self.DATADICT[pulse]["TIMES"], (E0,phi,df,T2))
                     #[success, E0, df, phi, T2] = decay.quadratureDetect( ht.real, ht.imag, self.DATADICT[pulse]["TIMES"] )
                     #print("success", success, "E0", E0, "phi", phi, "df", df, "T2", T2)
 
 
 
-    def loadMIDI2(self, directory, procStacks, chanin, rchanin, FIDProc, canvas, deadTime, plot):
+    def loadMIDI2(self, directory, procStacks, chanin, rchanin, FIDProc, canvas, deadTime, pulseMoments, plot):
         """Reads a MRS MIDI2 experiment. 
         """
+
+        print("Loading MIDI2 data")
+
         canvas.reAx3(True,False)
 
         chan = []
         PULSES = [FIDProc]
         PULSES = ["Pulse 1"]
 
+        if pulseMoments[0] == -1:
+            print("using default pulse moments, all of them")
+            self.pulseMoments = range(0, self.nPulseMoments) # use all of them, assume starting at 0 
+        else:
+            self.pulseMoments = pulseMoments
+        
+        self.nPulseMoments = len(self.pulseMoments)
+
+        print("nPulseMoments", self.nPulseMoments, self.pulseMoments)
+
         self.DATADICT = {}
         self.DATADICT["nPulseMoments"] = self.nPulseMoments
         self.DATADICT["stacks"] = procStacks
         iistack = 0
         idead = int( (self.pulseLength[0]+deadTime) / self.dt)
 
-        for iq in range(self.nPulseMoments):
+        
+        for ipm, iq in enumerate(self.pulseMoments):
 
             fidbase = self.datadir #+ self.QFiles[iq][0:-5]
             
                             break 
 
                     # use numpy for now, consider pandas for faster read? 
+                    print("Loading", FID)
                     DATA = np.genfromtxt(FID, skip_header=0, skip_footer=1 )
                     #DATA = pd.read_csv(fidname, skiprows=headerLine, skipfooter=1, sep='\t', encoding='ascii')
            
                     for ichan in np.append(chan,rchan):
                  
                         if int(ichan) <= 3: 
-                            self.DATADICT["Pulse 1"][ichan][iq][istack] = DATA[idead:,int(ichan)] / float(self.MIDIGain[int(ichan)-1])
+                            self.DATADICT["Pulse 1"][ichan][ipm][istack] = DATA[idead:,int(ichan)] / float(self.MIDIGain[int(ichan)-1])
 
                         elif int(ichan) > 3:     
-                            self.DATADICT["Pulse 1"][ichan][iq][istack] = DATA[idead:,int(ichan)+1] / float(self.MIDIGain[int(ichan)-1])
+                            self.DATADICT["Pulse 1"][ichan][ipm][istack] = DATA[idead:,int(ichan)+1] / float(self.MIDIGain[int(ichan)-1])
                    
                         # truncate after dead time  
 
                         # truncate until dead time
                         ipulse = int(self.pulseLength[0] / self.dt)
                         self.DATADICT["Pulse 1"]["PULSE_TIMES"] = DATA[0:ipulse,0]
-                        self.DATADICT["Pulse 1"]["CURRENT"][iq][istack] = DATA[0:ipulse,4]
+                        self.DATADICT["Pulse 1"]["CURRENT"][ipm][istack] = DATA[0:ipulse,4]
 
                         if plot: 
                             canvas.softClear()                           
 
                             for ichan in chan:
-                                canvas.ax1.plot(self.DATADICT["Pulse 1"]["PULSE_TIMES"], self.DATADICT["Pulse 1"]["CURRENT"][iq][istack] , color='black')
-                                canvas.ax3.plot(self.DATADICT["Pulse 1"]["TIMES"],       self.DATADICT["Pulse 1"][ichan][iq][istack], label="Pulse 1 FID data ch. "+str(ichan)) #, color='blue')
+                                canvas.ax1.plot(self.DATADICT["Pulse 1"]["PULSE_TIMES"], self.DATADICT["Pulse 1"]["CURRENT"][ipm][istack] , color='black')
+                                canvas.ax3.plot(self.DATADICT["Pulse 1"]["TIMES"],       self.DATADICT["Pulse 1"][ichan][ipm][istack], label="Pulse 1 FID data ch. "+str(ichan)) #, color='blue')
 
                             for ichan in rchan:
-                                canvas.ax2.plot(self.DATADICT["Pulse 1"]["TIMES"], self.DATADICT["Pulse 1"][ichan][iq][istack], label="Pulse 1 FID ref ch. "+str(ichan)) #, color='blue')
+                                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')
 
                             # 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(iq), fontsize=10)
-                            canvas.ax2.set_ylabel("RAW signal [V]", fontsize=10)
+                            if len(rchan) > 0:
+                                canvas.ax2.legend(prop={'size':10}, loc='upper right')
+                                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.set_title("stack "+str(istack)+" pulse index " + str(iq), fontsize=10)
+                                canvas.ax2.set_ylabel("RAW signal [V]", fontsize=10)
 
                             canvas.ax1.set_ylabel("Current (A)", fontsize=10) 
                             canvas.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y') 

setup.py

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