schain-jc Commit - r1201:2ee3e6bd4db0

Fix bug in CrossSpectraPlot

George Yong -

r1201:2ee3e6bd4db0

parent child

Context file:

r1201:2ee3e6bd4db0

Collapse all files

schainpy/model/data/jrodata.py +13 -8

                 MAXNUMY = 100
                 def __init__(self, code, throttle_value, exp_code, buffering=True):
                     self.throttle = throttle_value
                     self.exp_code = exp_code
                     self.buffering = buffering
                             plot = 'snr'
                         self.data[plot] = {}
-                    if 'spc' in self.data or 'rti' in self.data:
+                    if 'spc' in self.data or 'rti' in self.data or 'cspc' in self.data:
                         self.data['noise'] = {}
                         if 'noise' not in self.plottypes:
                             self.plottypes.append('noise')
                 def shape(self, key):
                     '''
                     Get the shape of the one-element data for the given key
                     '''
                     Update data object with new dataOut
                     '''
                     if tm in self.__times:
                         return
                     self.type = dataOut.type
                     self.parameters = getattr(dataOut, 'parameters', [])
                     if hasattr(dataOut, 'pairsList'):
                     if 'spc' in self.plottypes or 'cspc' in self.plottypes:
                         self.xrange = (dataOut.getFreqRange(1)/1000.,
                                        dataOut.getAcfRange(1), dataOut.getVelRange(1))
+                        self.factor = dataOut.normFactor
                     self.__heights.append(dataOut.heightList)
                     self.__all_heights.update(dataOut.heightList)
                     self.__times.append(tm)
                     for plot in self.plottypes:
                         if plot == 'spc':
                             z = dataOut.data_spc/dataOut.normFactor
                             buffer = 10*numpy.log10(z)
                         if plot == 'cspc':
-                            buffer = dataOut.data_cspc
+                            z = dataOut.data_spc/dataOut.normFactor
+                            buffer = (dataOut.data_spc, dataOut.data_cspc)
                         if plot == 'noise':
                             buffer = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                         if plot == 'rti':
                         if plot == 'param':
                             buffer = dataOut.data_param
-                        if 'spc' in plot:
+                        if plot == 'spc':
                             self.data[plot] = buffer
+                        elif plot == 'cspc':
+                            self.data['spc'] = buffer[0]
+                            self.data['cspc'] = buffer[1]
                         else:
                             if self.buffering:
                                 self.data[plot][tm] = buffer

schainpy/model/graphics/jroplot_base.py +1 -1

                             ax.set_title('{} {} {}'.format(
                                 self.titles[n],
                                 self.getDateTime(self.data.max_time).strftime(
-                                    '%Y-%m-%dT%H:%M:%S'),
+                                    '%H:%M:%S'),
                                 self.time_label),
                                 size=8)
                         else:

schainpy/model/graphics/jroplot_data.py +22 -19

             class CrossSpectraPlot(Plot):
                 CODE = 'cspc'
+                colormap = 'jet'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                         noise = self.data['noise'][n][-1]
                         pair = self.data.pairs[n]
                         ax = self.axes[4 * n]
-                        ax3 = self.axes[4 * n + 3]
+                        spc0 = 10.*numpy.log10(spc[pair[0]]/self.data.factor)
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(spc)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(spc)
-                            ax.plt = ax.pcolormesh(x, y, spc[pair[0]].T,
+                            ax.plt = ax.pcolormesh(x , y , spc0.T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
+                                                   )
                         else:
-                            ax.plt.set_array(spc[pair[0]].T.ravel())
+                            ax.plt.set_array(spc0.T.ravel())
-                        self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
+                        self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise))
                         ax = self.axes[4 * n + 1]
+                        spc1 = 10.*numpy.log10(spc[pair[1]]/self.data.factor)
                         if ax.firsttime:
-                            ax.plt = ax.pcolormesh(x, y, spc[pair[1]].T,
+                            ax.plt = ax.pcolormesh(x , y, spc1.T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
-                            ax.plt.set_array(spc[pair[1]].T.ravel())
+                            ax.plt.set_array(spc1.T.ravel())
-                        self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
+                        self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise))
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                             ax.plt.set_array(coh.T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[4 * n + 3]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                     self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
                     self.titles = ['{} {}'.format(
                         self.data.parameters[x], title) for x in self.channels]
+  No newline at end of file

schainpy/model/proc/jroproc_base.py +3 -4

                         self.sender = None
                         self.receiver = None
                         self.name = BaseClass.__name__
-                        if 'plot' in self.name.lower():
+                        if 'plot' in self.name.lower() and not self.name.endswith('_'):
-                            if not self.name.endswith('_'):
+                            self.name = '{}{}'.format(self.CODE.upper(), 'Plot')
-                                self.name = '{}{}'.format(self.CODE.upper(), 'Plot')
                         self.start_time = time.time()
                         if len(self.args) is 3:
                                     op(**kwargs)
                                 elif optype == 'other' and not self.dataOut.flagNoData:
                                     self.dataOut = op.run(self.dataOut, **kwargs)
-                                elif optype == 'external':
+                                elif optype == 'external' and not self.dataOut.flagNoData:
                                     if not self.dataOut.flagNoData or self.dataOut.error:
                                         self.publish(self.dataOut, opId)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages