Improvements to plotting of pulse moment calculation.

akvo/terminal/plotyaml.py

-import yaml
+from ruamel import yaml
 import os, sys
 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
+import matplotlib.ticker as plticker
+
 def slicedict(d, s):
     return {k:v for k,v in d.items() if k.startswith(s)}
 
         # Converts to a dictionary with Eigen vectors represented as Numpy arrays 
         return self
 
-def loadAkvoData(fnamein, chan):
+def loadAkvoData(fnamein):
     """ Loads data from an Akvo YAML file. The 0.02 is hard coded as the pulse length. This needs to be 
         corrected in future kernel calculations. The current was reported but not the pulse length. 
     """
     fname = (os.path.splitext(fnamein)[0])
     with open(fnamein, 'r') as stream:
         try:
-            AKVO = (yaml.load(stream))
+            AKVO = (yaml.load(stream, Loader=yaml.Loader))
         except yaml.YAMLError as exc:
             print(exc)
     return AKVO 
 
 def plotQt( akvo ):
-    import matplotlib.pyplot as plt
+ 
     plt.style.use('ggplot')
+    #plt.style.use('seaborn-white')
     for pulse in akvo.Gated:
         if pulse[0:5] == "Pulse":
             #print(akvo.GATED[pulse].keys())
             nq = akvo.Pulses[pulse]["current"].size
             for chan in slicedict(akvo.Gated[pulse], "Chan."):
                 # accumulate pulse moments
-                X = np.zeros( (nq, len( akvo.Gated[pulse]["abscissa"].data )) )
+                CA = np.zeros( (nq, len( akvo.Gated[pulse]["abscissa"].data )) )
+                RE = np.zeros( (nq, len( akvo.Gated[pulse]["abscissa"].data )) )
+                IM = np.zeros( (nq, len( akvo.Gated[pulse]["abscissa"].data )) )
                 for q in range(nq):
-                    plt.plot(  akvo.Gated[pulse]["abscissa"].data,  akvo.Gated[pulse][chan]["Q-" + str(q)+" CA"].data ) 
-                    X[q] = akvo.Gated[pulse][chan]["Q-" + str(q)+" CA"].data
-    plt.matshow(X)
+                    #plt.plot(  akvo.Gated[pulse]["abscissa"].data,  akvo.Gated[pulse][chan]["Q-" + str(q)+" CA"].data ) 
+                    CA[q] = akvo.Gated[pulse][chan]["Q-" + str(q)+" CA"].data
+                    RE[q] = akvo.Gated[pulse][chan]["Q-" + str(q)+" RE"].data
+                    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
+            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))))
+            cb = plt.colorbar( im, orientation='horizontal', pad=.175,  )
+            cb.set_label("FID (nV)", fontsize=10)
+            cb.ax.tick_params(labelsize=10) 
+            ax1.set_yscale('log')
+            ax1.set_ylabel("Q (A$\cdot$s)", fontsize=10)
+            ax1.set_xscale('log')
+            ax1.set_xlabel("time (s)", fontsize=10)
+
+            #loc = plticker.MultipleLocator(25) #base=50.0) # this locator puts ticks at regular intervals
+            #loc = plticker.MaxNLocator(5, steps=[1,2]) #base=50.0) # this locator puts ticks at regular intervals
+            #ax1.xaxis.set_major_locator(loc)
+
+            #ax1.xaxis.set_minor_locator(plticker.NullLocator())
+            ax1.xaxis.set_major_formatter(FormatStrFormatter('%2.0f'))
+            ax1.yaxis.set_major_formatter(FormatStrFormatter('%2.1f'))
+
+            #plt.figure()
+            #sns.kdeplot(Windows, Q, CA) #, kind="hex", color="#4CB391")
+            #sns.heatmap(CA, annot=False, center=0)
+
+    #plt.matshow(RE)
+    #plt.matshow(IM)
+
+
 
     plt.show()
 if __name__ == "__main__":
-    akvo = loadAkvoData( sys.argv[1] , "Chan. 1")
+    akvo = loadAkvoData( sys.argv[1] ) #, "Chan. 1")
     plotQt(akvo)

akvo/tressel/mrsurvey.py

                 ax1.set_xlabel(r"time (ms)", fontsize=8)
 
                 if ichan == 0:
-                    ax1.set_ylabel(r"signal [nV]", fontsize=8)
+                    ax1.set_ylabel(r"signal (nV)", fontsize=8)
                 else:
                     plt.setp(ax1.get_yticklabels(), visible=False)
                     plt.setp(ax1.get_yaxis().get_offset_text(), visible=False) 
                 #im2.append(ax2.matshow( db, aspect='auto', vmin=vvmin, vmax=vvmax))
                 #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"$q$ (A $\cdot$ s)", fontsize=8)
+                    ax2.set_ylabel(r"pulse index", fontsize=8)
+                    #ax1.set_ylabel(r"FID (nV)", fontsize=8)
                 else:
                     #ax2.yaxis.set_ticklabels([])
                     plt.setp(ax2.get_yticklabels(), visible=False)
                 ax1 = axes[2*ichan  ]
                 ax2 = axes[2*ichan+1] # TODO fix hard coded number
                 if phase == 0: # Re Im 
-                    print("plot dog", np.shape(QQ), np.shape(self.DATADICT["RE"][pulse][chan]))
-                    print("QQ", QQ) 
+                    #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] )
                     im2 = ax2.pcolormesh( time_sp, QQ[iQ], self.DATADICT["IM"][pulse][chan][iQ], cmap=dcmap, \
         
         canvas.reAxH(2)
         nstack = len(self.DATADICT["stacks"]) 
-        canvas.ax1.set_yscale('log')
+        #canvas.ax1.set_yscale('log')
 
         for pulse in self.DATADICT["PULSES"]:
             self.DATADICT[pulse]["qeff"] = {}
                     v = np.fft.fftfreq(len(x), self.dt)
                     v = v[0:len(X)]
                     v[-1] = np.abs(v[-1])
+
                     # calculate effective current/moment
                     I0 = np.abs(X)/len(X) 
-                    qeff = I0 * (self.DATADICT[pulse]["PULSE_TIMES"][-1]-self.DATADICT[pulse]["PULSE_TIMES"][0])
-                    canvas.ax1.set_title(r"pulse moment index " +str(ipm), fontsize=10)
-                    canvas.ax1.set_xlabel(r"$\nu$ [Hz]", fontsize=8)
-                    canvas.ax1.set_ylabel(r"$q_{eff}$ [A$\cdot$sec]", fontsize=8)
-                    canvas.ax1.plot(v, qeff, color=scolours[iistack] ) # eff current
+                    qeff = I0 #* (self.DATADICT[pulse]["PULSE_TIMES"][-1]-self.DATADICT[pulse]["PULSE_TIMES"][0])
+
+                    # frequency plot
+                    #canvas.ax1.set_title(r"pulse moment index " +str(ipm), fontsize=10)
+                    #canvas.ax1.set_xlabel(r"$\nu$ [Hz]", fontsize=8)
+                    #canvas.ax1.set_ylabel(r"$q_{eff}$ [A$\cdot$sec]", fontsize=8)
+                    #canvas.ax1.plot(v, qeff, color=scolours[iistack] ) # eff current
+                    
+                    # time plot
+                    canvas.ax1.plot(1e2*(self.DATADICT[pulse]["PULSE_TIMES"]-self.DATADICT[pulse]["PULSE_TIMES"][0]), x, color=scolours[iistack])
+
                     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()
+
                         
                 percent = int(1e2* (float)((istack)+ipm*self.DATADICT["nPulseMoments"]) / 
                                    (float)(len(self.DATADICT["PULSES"])*self.DATADICT["nPulseMoments"]*nstack))
                 istack = 0
                 for stack in self.DATADICT["stacks"]:
                     # find index 
-                    icv = int (round(cv / self.DATADICT[pulse]["q_nu"][ipm][stack][1]))
+                    icv = int(round(cv / self.DATADICT[pulse]["q_nu"][ipm][stack][1]))
                     self.DATADICT[pulse]["Q"][ipm,istack] = self.DATADICT[pulse]["qeff"][ipm][stack][icv]
                     if ilabel:
                         ax.scatter(ipm, self.DATADICT[pulse]["qeff"][ipm][stack][icv], facecolors='none', edgecolors=scolours[istack], label=(str(pulse)))