v1.2.7

akvo/gui/akvoGUI.py

         # Add some extra info 
         INFO = {}
         INFO["pulseType"] = self.RAWDataProc.pulseType
+        INFO["prePulseDelay"] = self.RAWDataProc.prePulseDelay
         INFO["interpulseDelay"] = self.RAWDataProc.interpulseDelay
         INFO["transFreq"] = self.RAWDataProc.transFreq
         INFO["pulseLength"] = self.RAWDataProc.pulseLength
         self.RAWDataProc.deadTime = self.RAWDataProc.DATADICT["INFO"]["deadTime"] 
         self.RAWDataProc.transFreq = self.RAWDataProc.DATADICT["INFO"]["transFreq"]
         self.RAWDataProc.nDAQVersion = self.RAWDataProc.DATADICT["INFO"]["nDAQVersion"]
+        #self.RAWDataProc.prePulseDelay = self.RAWDataProc.DATADICT["INFO"]["prePulseDelay"]
         self.RAWDataProc.dt = 1./self.RAWDataProc.samp 
 
         self.dataChan = self.RAWDataProc.DATADICT[ self.RAWDataProc.DATADICT["PULSES"][0] ]["chan"]
         self.ui.lcdTotalDeadTime.setEnabled(1)
         
         #self.ui.lcdTotalDeadTime.display( 1e3*self.RAWDataProc.DATADICT["INFO"]["deadTime"] )
-        self.ui.lcdTotalDeadTime.display( 1e3 * (self.RAWDataProc.DATADICT["Pulse 1"]["TIMES"][0]-self.RAWDataProc.DATADICT["Pulse 1"]["PULSE_TIMES"][-1]) )
 
         self.ui.headerFileTextBrowser.clear( ) 
         self.ui.headerFileTextBrowser.append( self.RAWDataProc.DATADICT["INFO"]["headerstr"] )
         
         if u"Pulse 1" in self.RAWDataProc.DATADICT.keys():
             self.ui.lcdNumberFID1Length.display(self.RAWDataProc.DATADICT["Pulse 1"]["TIMES"][-1]- self.RAWDataProc.DATADICT["Pulse 1"]["TIMES"][0])
+            self.ui.lcdTotalDeadTime.display( round(1e3*(self.RAWDataProc.DATADICT["Pulse 1"]["TIMES"][0]-self.RAWDataProc.DATADICT["Pulse 1"]["PULSE_TIMES"][-1]), 3) )
+            print("CALC DEAD",    (1e3*(self.RAWDataProc.prePulseDelay))) # -  (self.RAWDataProc.DATADICT["Pulse 1"]["TIMES"][0]-self.RAWDataProc.DATADICT["Pulse 1"]["PULSE_TIMES"][-1])), 3) )
         if u"Pulse 2" in self.RAWDataProc.DATADICT.keys():
             self.ui.lcdNumberFID1Length.display(self.RAWDataProc.DATADICT["Pulse 2"]["TIMES"][-1]- self.RAWDataProc.DATADICT["Pulse 2"]["TIMES"][0])
+            self.ui.lcdTotalDeadTime.display( 1e3 * (self.RAWDataProc.DATADICT["Pulse 2"]["TIMES"][0]-self.RAWDataProc.DATADICT["Pulse 2"]["PULSE_TIMES"][-1]) )
  
         # Update info from the header into the GUI
         self.ui.pulseTypeTextBrowser.clear()
         self.ui.lcdTotalDeadTime.setEnabled(1)
 
         self.ui.lcdTotalDeadTime.display( self.ui.DeadTimeSpinBox.value( ) )
+        #self.ui.lcdTotalDeadTime.display( round(1e3*(self.RAWDataProc.DATADICT["Pulse 1"]["TIMES"][0]-self.RAWDataProc.DATADICT["Pulse 1"]["PULSE_TIMES"][-1]), 3) )
         
         #self.ui.lcdNumberFID1Length.display(0)
         #self.ui.lcdNumberFID2Length.display(0)

akvo/tressel/mrsurvey.py

                                        (float)(self.DATADICT["nPulseMoments"] * len(self.DATADICT[pulse]["chan"])))
                     self.progressTrigger.emit(percent)
                 ichan += 1
+            self.DATADICT[pulse]["TIMES"] = self.DATADICT[pulse]["TIMES"][clip::]
 
         self.DATADICT["CA"] = CA
         self.DATADICT["IP"] = IP
             axes = canvas.fig.axes
             mmaxr = 0.
             mmaxi = 0.
-            if clip > 0:
-                time_sp =  1e3 * (self.DATADICT[pulse]["TIMES"][clip-1::] - self.DATADICT[pulse]["PULSE_TIMES"][-1] )
-            else:
-                time_sp =  1e3 * (self.DATADICT[pulse]["TIMES"] - self.DATADICT[pulse]["PULSE_TIMES"][-1] )
+            #if clip > 0:
+            #    time_sp =  1e3 * (self.DATADICT[pulse]["TIMES"][clip-1::] - self.DATADICT[pulse]["PULSE_TIMES"][-1] )
+            #else:
+            #    time_sp =  1e3 * (self.DATADICT[pulse]["TIMES"] - self.DATADICT[pulse]["PULSE_TIMES"][-1] )
+            time_sp =  1e3 * (self.DATADICT[pulse]["TIMES"] - self.DATADICT[pulse]["PULSE_TIMES"][-1] )
                 
             QQ = np.average(self.DATADICT[pulse]["Q"], axis=1 )
  
                 if self.GATED[chan]["isum"][it] < 8:
                     XS[ii, it] = self.sigma[pulse][chan]
                 else:
-                                
                     if it == 0:                
-                        X = self.bootstrap_resample( np.concatenate( (self.GATED[chan]["NR"][:,it], self.GATED[chan]["NR"][:,it+1], \
-                            self.GATED[chan]["NR"][:,it+2], self.GATED[chan]["NR"][:,it+3] ) ), n=nt )
+                        X = self.bootstrap_resample( np.concatenate( (self.GATED[chan]["NR"][:,it],   \
+                                                                      self.GATED[chan]["NR"][:,it+1], \
+                                                                      self.GATED[chan]["NR"][:,it+2], \
+                                                                      self.GATED[chan]["NR"][:,it+3] ) ), n=nt )
                     elif it == 1:                
                         X = self.bootstrap_resample( np.concatenate( (self.GATED[chan]["NR"][:,it-1], self.GATED[chan]["NR"][:,it], \
                             self.GATED[chan]["NR"][:,it+1], self.GATED[chan]["NR"][:,it+2] ) ), n=nt )
         
         canvas.reAxH2(  len(self.DATADICT[ self.DATADICT["PULSES"][0] ]["chan"] ), False, False)
         axes = canvas.fig.axes
-        cmap = cmocean.cm.balance_r 
+        #cmap = cmocean.cm.balance_r 
+        dcmap = cmocean.cm.curl_r  #"seismic_r" #cmocean.cm.balance_r #"RdBu" #YlGn" # "coolwarm_r"  # diverging 
     
         # Calculate maximum for plotting...TODO move into loop above
         vmax1 = 0
                 ax2 = axes[2*ichan+1] 
                 
                 if phase == 0:
-                    im1 = ax1.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["RE"], cmap=cmap, vmin=-vmax1, vmax=vmax1)
-                    im2 = ax2.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["IM"], cmap=cmap, vmin=-vmax2, vmax=vmax2)
+                    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)
                 elif phase == 1:
-                    im1 = ax1.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["CA"], cmap=cmap, vmin=-vmax1, vmax=vmax1)
-                    im2 = ax2.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["IP"], cmap=cmocean.cm.balance, vmin=-vmax2, vmax=vmax2)
+                    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)
                     #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=cmap, vmin=-vmax1, vmax=vmax1)
+                    im1 = ax1.pcolormesh(self.GATED[chan]["GTT"], self.GATED[chan]["QQ"], self.GATED[chan]["CA"], 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
                 if phase != 2:
                     im2.set_edgecolor('face')
 
-
                 plt.setp(ax1.get_xticklabels(), visible=False)
         
                 ax1.set_ylim( np.min(self.GATED[chan]["QQ"]), np.max(self.GATED[chan]["QQ"]) )
                 #formatter = matplotlib.ticker.LogFormatter(10, labelOnlyBase=False)
                 formatter = matplotlib.ticker.FuncFormatter(lambda x, pos: str((round(x,1)))) 
                 
+                ax1.set_xscale('log')
+                ax2.set_xscale('log')
+                
                 ax1.yaxis.set_major_formatter(formatter) #matplotlib.ticker.FormatStrFormatter('%d.1'))
                 ax2.yaxis.set_major_formatter(formatter) #matplotlib.ticker.FormatStrFormatter('%d.1'))
 
                 ax1.xaxis.set_major_formatter(formatter) #matplotlib.ticker.FormatStrFormatter('%d.1'))
                 ax2.xaxis.set_major_formatter(formatter) #matplotlib.ticker.FormatStrFormatter('%d.1'))
                 
-                ax1.set_xscale('log')
-                ax2.set_xscale('log')
-                
                 if ichan == 0:
                     ax1.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=8)
                     if phase == 2:
         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.locator = tick_locator
-        cb1.update_ticks()
+        #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)

akvo/tressel/rotate.py

     return np.abs(V) * np.exp( 1j * ( np.angle(V) - zeta - 2.*np.pi*df*t ) )
     #return np.abs(V) * np.exp( 1j * ( np.angle(V) - zeta - df*t ) )
 
+def bootstrapWindows(N, nboot, isum, adapt=False):
+    """ Bootstraps noise as a function of gate width
+        N = input noise signal 
+        nboot = number of boostrap windows to perform 
+        isum = length of windows (L_i)
+        adapt = reduce nboot as window size increases
+    """
+    nc = np.shape(N)[0]
+    Means = {}
+
+    if adapt:
+        Means = -9999*np.ones((len(isum), nboot//isum[0])) # dummy value
+        for ii, nwin in enumerate(isum):  
+            for iboot in range(nboot//isum[ii]):
+                cs = np.random.randint(0,nc-nwin)
+                Means[ii,iboot] = np.mean( N[cs:cs+nwin] )
+        Means = np.ma.masked_less(Means, -9995)
+
+    else:
+        Means = np.zeros((len(isum), nboot))
+        for ii, nwin in enumerate(isum):  
+            for iboot in range(nboot):
+                cs = np.random.randint(0,nc-nwin)
+                Means[ii,iboot] = np.mean( N[cs:cs+nwin] )
+
+    return Means, np.array(isum)
+
 def gateIntegrate(T2D, T2T, gpd, sigma, stackEfficiency=2.):
     """ Gate integrate the signal to gpd, gates per decade
         T2D = the time series to gate integrate, complex