jroplot_spectra.py
650 lines
| 21.2 KiB
| text/x-python
|
PythonLexer
|
r487 | ''' | |
|
r568 | Created on Jul 9, 2014 | |
|
r1285 | Modified on May 10, 2020 | |
|
r568 | ||
|
r1285 | @author: Juan C. Espinoza | |
|
r487 | ''' | |
|
r1285 | ||
|
r487 | import os | |
import datetime | |||
import numpy | |||
|
r1285 | from schainpy.model.graphics.jroplot_base import Plot, plt | |
|
r953 | ||
|
r858 | ||
|
r1285 | class SpectraPlot(Plot): | |
''' | |||
Plot for Spectra data | |||
''' | |||
|
r858 | ||
|
r1285 | CODE = 'spc' | |
colormap = 'jet' | |||
plot_name = 'Spectra' | |||
plot_type = 'pcolor' | |||
|
r858 | ||
|
r1285 | def setup(self): | |
self.nplots = len(self.data.channels) | |||
self.ncols = int(numpy.sqrt(self.nplots) + 0.9) | |||
self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9) | |||
self.height = 3 * self.nrows | |||
self.cb_label = 'dB' | |||
if self.showprofile: | |||
self.width = 4 * self.ncols | |||
|
r487 | else: | |
|
r1285 | self.width = 3.5 * self.ncols | |
self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08}) | |||
self.ylabel = 'Range [km]' | |||
def plot(self): | |||
if self.xaxis == "frequency": | |||
x = self.data.xrange[0] | |||
self.xlabel = "Frequency (kHz)" | |||
elif self.xaxis == "time": | |||
x = self.data.xrange[1] | |||
self.xlabel = "Time (ms)" | |||
|
r965 | else: | |
|
r1285 | x = self.data.xrange[2] | |
self.xlabel = "Velocity (m/s)" | |||
if self.CODE == 'spc_moments': | |||
x = self.data.xrange[2] | |||
self.xlabel = "Velocity (m/s)" | |||
self.titles = [] | |||
y = self.data.heights | |||
self.y = y | |||
z = self.data['spc'] | |||
for n, ax in enumerate(self.axes): | |||
noise = self.data['noise'][n][-1] | |||
if self.CODE == 'spc_moments': | |||
mean = self.data['moments'][n, :, 1, :][-1] | |||
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(z) | |||
self.zmax = self.zmax if self.zmax else numpy.nanmax(z) | |||
ax.plt = ax.pcolormesh(x, y, z[n].T, | |||
vmin=self.zmin, | |||
vmax=self.zmax, | |||
cmap=plt.get_cmap(self.colormap) | |||
) | |||
if self.showprofile: | |||
ax.plt_profile = self.pf_axes[n].plot( | |||
self.data['rti'][n][-1], y)[0] | |||
ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y, | |||
color="k", linestyle="dashed", lw=1)[0] | |||
if self.CODE == 'spc_moments': | |||
ax.plt_mean = ax.plot(mean, y, color='k')[0] | |||
else: | |||
ax.plt.set_array(z[n].T.ravel()) | |||
if self.showprofile: | |||
ax.plt_profile.set_data(self.data['rti'][n][-1], y) | |||
ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y) | |||
if self.CODE == 'spc_moments': | |||
ax.plt_mean.set_data(mean, y) | |||
self.titles.append('CH {}: {:3.2f}dB'.format(n, noise)) | |||
class CrossSpectraPlot(Plot): | |||
CODE = 'cspc' | |||
colormap = 'jet' | |||
plot_name = 'CrossSpectra' | |||
plot_type = 'pcolor' | |||
zmin_coh = None | |||
zmax_coh = None | |||
zmin_phase = None | |||
zmax_phase = None | |||
def setup(self): | |||
self.ncols = 4 | |||
self.nrows = len(self.data.pairs) | |||
self.nplots = self.nrows * 4 | |||
self.width = 3.4 * self.ncols | |||
self.height = 3 * self.nrows | |||
self.ylabel = 'Range [km]' | |||
self.showprofile = False | |||
self.plots_adjust.update({'bottom': 0.08}) | |||
def plot(self): | |||
if self.xaxis == "frequency": | |||
x = self.data.xrange[0] | |||
self.xlabel = "Frequency (kHz)" | |||
elif self.xaxis == "time": | |||
x = self.data.xrange[1] | |||
self.xlabel = "Time (ms)" | |||
|
r777 | else: | |
|
r1285 | x = self.data.xrange[2] | |
self.xlabel = "Velocity (m/s)" | |||
|
r1027 | ||
|
r1285 | self.titles = [] | |
y = self.data.heights | |||
self.y = y | |||
spc = self.data['spc'] | |||
cspc = self.data['cspc'] | |||
for n in range(self.nrows): | |||
noise = self.data['noise'][n][-1] | |||
pair = self.data.pairs[n] | |||
ax = self.axes[4 * n] | |||
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 , spc0.T, | |||
vmin=self.zmin, | |||
vmax=self.zmax, | |||
cmap=plt.get_cmap(self.colormap) | |||
) | |||
else: | |||
ax.plt.set_array(spc0.T.ravel()) | |||
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, spc1.T, | |||
vmin=self.zmin, | |||
vmax=self.zmax, | |||
cmap=plt.get_cmap(self.colormap) | |||
) | |||
else: | |||
ax.plt.set_array(spc1.T.ravel()) | |||
self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise)) | |||
|
r965 | ||
|
r1285 | 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 = self.axes[4 * n + 2] | |||
if ax.firsttime: | |||
ax.plt = ax.pcolormesh(x, y, coh.T, | |||
vmin=0, | |||
vmax=1, | |||
cmap=plt.get_cmap(self.colormap_coh) | |||
) | |||
else: | |||
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.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1])) | |||
class RTIPlot(Plot): | |||
''' | |||
Plot for RTI data | |||
''' | |||
CODE = 'rti' | |||
colormap = 'jet' | |||
plot_name = 'RTI' | |||
plot_type = 'pcolorbuffer' | |||
def setup(self): | |||
self.xaxis = 'time' | |||
self.ncols = 1 | |||
self.nrows = len(self.data.channels) | |||
self.nplots = len(self.data.channels) | |||
self.ylabel = 'Range [km]' | |||
self.xlabel = 'Time' | |||
self.cb_label = 'dB' | |||
self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95}) | |||
self.titles = ['{} Channel {}'.format( | |||
self.CODE.upper(), x) for x in range(self.nrows)] | |||
def plot(self): | |||
self.x = self.data.times | |||
self.y = self.data.heights | |||
self.z = self.data[self.CODE] | |||
self.z = numpy.ma.masked_invalid(self.z) | |||
if self.decimation is None: | |||
x, y, z = self.fill_gaps(self.x, self.y, self.z) | |||
|
r965 | else: | |
|
r1285 | x, y, z = self.fill_gaps(*self.decimate()) | |
for n, ax in enumerate(self.axes): | |||
self.zmin = self.zmin if self.zmin else numpy.min(self.z) | |||
self.zmax = self.zmax if self.zmax else numpy.max(self.z) | |||
if ax.firsttime: | |||
ax.plt = ax.pcolormesh(x, y, z[n].T, | |||
vmin=self.zmin, | |||
vmax=self.zmax, | |||
cmap=plt.get_cmap(self.colormap) | |||
) | |||
if self.showprofile: | |||
ax.plot_profile = self.pf_axes[n].plot( | |||
self.data['rti'][n][-1], self.y)[0] | |||
ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y, | |||
color="k", linestyle="dashed", lw=1)[0] | |||
else: | |||
ax.collections.remove(ax.collections[0]) | |||
ax.plt = ax.pcolormesh(x, y, z[n].T, | |||
vmin=self.zmin, | |||
vmax=self.zmax, | |||
cmap=plt.get_cmap(self.colormap) | |||
) | |||
if self.showprofile: | |||
ax.plot_profile.set_data(self.data['rti'][n][-1], self.y) | |||
ax.plot_noise.set_data(numpy.repeat( | |||
self.data['noise'][n][-1], len(self.y)), self.y) | |||
class CoherencePlot(RTIPlot): | |||
''' | |||
Plot for Coherence data | |||
''' | |||
CODE = 'coh' | |||
plot_name = 'Coherence' | |||
def setup(self): | |||
self.xaxis = 'time' | |||
self.ncols = 1 | |||
self.nrows = len(self.data.pairs) | |||
self.nplots = len(self.data.pairs) | |||
self.ylabel = 'Range [km]' | |||
self.xlabel = 'Time' | |||
self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1,'right':0.95}) | |||
if self.CODE == 'coh': | |||
self.cb_label = '' | |||
self.titles = [ | |||
'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs] | |||
|
r825 | else: | |
|
r1285 | self.cb_label = 'Degrees' | |
self.titles = [ | |||
'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs] | |||
|
r858 | ||
|
r1285 | class PhasePlot(CoherencePlot): | |
''' | |||
Plot for Phase map data | |||
''' | |||
|
r858 | ||
|
r1285 | CODE = 'phase' | |
colormap = 'seismic' | |||
plot_name = 'Phase' | |||
|
r858 | ||
|
r1285 | class NoisePlot(Plot): | |
''' | |||
Plot for noise | |||
''' | |||
|
r858 | ||
|
r1285 | CODE = 'noise' | |
plot_name = 'Noise' | |||
plot_type = 'scatterbuffer' | |||
|
r858 | ||
|
r1285 | def setup(self): | |
self.xaxis = 'time' | |||
self.ncols = 1 | |||
self.nrows = 1 | |||
self.nplots = 1 | |||
self.ylabel = 'Intensity [dB]' | |||
self.titles = ['Noise'] | |||
self.colorbar = False | |||
|
r858 | ||
|
r1285 | def plot(self): | |
|
r858 | ||
|
r1285 | x = self.data.times | |
xmin = self.data.min_time | |||
xmax = xmin + self.xrange * 60 * 60 | |||
Y = self.data[self.CODE] | |||
|
r858 | ||
|
r1285 | if self.axes[0].firsttime: | |
for ch in self.data.channels: | |||
y = Y[ch] | |||
self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch)) | |||
plt.legend() | |||
|
r832 | else: | |
|
r1285 | for ch in self.data.channels: | |
y = Y[ch] | |||
self.axes[0].lines[ch].set_data(x, y) | |||
|
r858 | ||
|
r1285 | self.ymin = numpy.nanmin(Y) - 5 | |
self.ymax = numpy.nanmax(Y) + 5 | |||
|
r487 | ||
|
r858 | ||
|
r1285 | class PowerProfilePlot(Plot): | |
|
r858 | ||
|
r1285 | CODE = 'spcprofile' | |
plot_name = 'Power Profile' | |||
plot_type = 'scatter' | |||
buffering = False | |||
|
r858 | ||
|
r1285 | def setup(self): | |
|
r858 | ||
|
r1285 | self.ncols = 1 | |
self.nrows = 1 | |||
self.nplots = 1 | |||
self.height = 4 | |||
self.width = 3 | |||
self.ylabel = 'Range [km]' | |||
self.xlabel = 'Intensity [dB]' | |||
self.titles = ['Power Profile'] | |||
self.colorbar = False | |||
|
r858 | ||
|
r1285 | def plot(self): | |
|
r858 | ||
|
r1285 | y = self.data.heights | |
self.y = y | |||
|
r858 | ||
|
r1285 | x = self.data['spcprofile'] | |
|
r1171 | ||
|
r1285 | if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9 | |
if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1 | |||
if self.axes[0].firsttime: | |||
for ch in self.data.channels: | |||
self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch)) | |||
plt.legend() | |||
|
r777 | else: | |
|
r1285 | for ch in self.data.channels: | |
self.axes[0].lines[ch].set_data(x[ch], y) | |||
class SpectraCutPlot(Plot): | |||
CODE = 'spc_cut' | |||
plot_name = 'Spectra Cut' | |||
plot_type = 'scatter' | |||
buffering = False | |||
def setup(self): | |||
self.nplots = len(self.data.channels) | |||
self.ncols = int(numpy.sqrt(self.nplots) + 0.9) | |||
self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9) | |||
self.width = 3.4 * self.ncols + 1.5 | |||
self.height = 3 * self.nrows | |||
self.ylabel = 'Power [dB]' | |||
self.colorbar = False | |||
self.plots_adjust.update({'left':0.1, 'hspace':0.3, 'right': 0.75, 'bottom':0.08}) | |||
def plot(self): | |||
if self.xaxis == "frequency": | |||
x = self.data.xrange[0][1:] | |||
self.xlabel = "Frequency (kHz)" | |||
elif self.xaxis == "time": | |||
x = self.data.xrange[1] | |||
self.xlabel = "Time (ms)" | |||
|
r487 | else: | |
|
r1285 | x = self.data.xrange[2] | |
self.xlabel = "Velocity (m/s)" | |||
|
r858 | ||
|
r1285 | self.titles = [] | |
|
r858 | ||
|
r1285 | y = self.data.heights | |
#self.y = y | |||
z = self.data['spc_cut'] | |||
|
r858 | ||
|
r1285 | if self.height_index: | |
index = numpy.array(self.height_index) | |||
|
r487 | else: | |
|
r1285 | index = numpy.arange(0, len(y), int((len(y))/9)) | |
|
r858 | ||
|
r1285 | for n, ax in enumerate(self.axes): | |
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.ymin = self.ymin if self.ymin else numpy.nanmin(z) | |||
self.ymax = self.ymax if self.ymax else numpy.nanmax(z) | |||
ax.plt = ax.plot(x, z[n, :, index].T) | |||
labels = ['Range = {:2.1f}km'.format(y[i]) for i in index] | |||
self.figures[0].legend(ax.plt, labels, loc='center right') | |||
else: | |||
for i, line in enumerate(ax.plt): | |||
line.set_data(x, z[n, :, i]) | |||
self.titles.append('CH {}'.format(n)) | |||
|
r858 | ||
|
r1171 | ||
|
r1285 | class BeaconPhase(Plot): | |
|
r858 | ||
|
r494 | __isConfig = None | |
__nsubplots = None | |||
PREFIX = 'beacon_phase' | |||
|
r858 | ||
|
r1179 | def __init__(self): | |
|
r1285 | Plot.__init__(self) | |
|
r494 | self.timerange = 24*60*60 | |
|
r760 | self.isConfig = False | |
|
r494 | self.__nsubplots = 1 | |
self.counter_imagwr = 0 | |||
|
r760 | self.WIDTH = 800 | |
self.HEIGHT = 400 | |||
|
r494 | self.WIDTHPROF = 120 | |
self.HEIGHTPROF = 0 | |||
self.xdata = None | |||
self.ydata = None | |||
|
r858 | ||
|
r573 | self.PLOT_CODE = BEACON_CODE | |
|
r858 | ||
|
r494 | self.FTP_WEI = None | |
self.EXP_CODE = None | |||
self.SUB_EXP_CODE = None | |||
self.PLOT_POS = None | |||
|
r858 | ||
|
r494 | self.filename_phase = None | |
|
r858 | ||
|
r494 | self.figfile = None | |
|
r858 | ||
|
r568 | self.xmin = None | |
self.xmax = None | |||
|
r858 | ||
|
r494 | def getSubplots(self): | |
|
r858 | ||
|
r494 | ncol = 1 | |
nrow = 1 | |||
|
r858 | ||
|
r494 | return nrow, ncol | |
|
r858 | ||
|
r494 | def setup(self, id, nplots, wintitle, showprofile=True, show=True): | |
|
r858 | ||
|
r494 | self.__showprofile = showprofile | |
self.nplots = nplots | |||
|
r858 | ||
|
r494 | ncolspan = 7 | |
colspan = 6 | |||
self.__nsubplots = 2 | |||
|
r858 | ||
|
r494 | self.createFigure(id = id, | |
wintitle = wintitle, | |||
widthplot = self.WIDTH+self.WIDTHPROF, | |||
heightplot = self.HEIGHT+self.HEIGHTPROF, | |||
show=show) | |||
|
r858 | ||
|
r494 | nrow, ncol = self.getSubplots() | |
|
r858 | ||
|
r494 | self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1) | |
def save_phase(self, filename_phase): | |||
|
r858 | f = open(filename_phase,'w+') | |
|
r494 | f.write('\n\n') | |
f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n') | |||
|
r858 | f.write('DD MM YYYY HH MM SS pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' ) | |
|
r494 | f.close() | |
def save_data(self, filename_phase, data, data_datetime): | |||
f=open(filename_phase,'a') | |||
timetuple_data = data_datetime.timetuple() | |||
day = str(timetuple_data.tm_mday) | |||
month = str(timetuple_data.tm_mon) | |||
year = str(timetuple_data.tm_year) | |||
hour = str(timetuple_data.tm_hour) | |||
minute = str(timetuple_data.tm_min) | |||
second = str(timetuple_data.tm_sec) | |||
f.write(day+' '+month+' '+year+' '+hour+' '+minute+' '+second+' '+str(data[0])+' '+str(data[1])+' '+str(data[2])+' '+str(data[3])+'\n') | |||
f.close() | |||
|
r1285 | def plot(self): | |
log.warning('TODO: Not yet implemented...') | |||
|
r494 | ||
def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True', | |||
|
r760 | xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None, | |
|
r494 | timerange=None, | |
|
r568 | save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1, | |
|
r494 | server=None, folder=None, username=None, password=None, | |
ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0): | |||
|
r858 | ||
|
r1171 | if dataOut.flagNoData: | |
return dataOut | |||
|
r760 | if not isTimeInHourRange(dataOut.datatime, xmin, xmax): | |
return | |||
|
r858 | ||
|
r494 | if pairsList == None: | |
|
r760 | pairsIndexList = dataOut.pairsIndexList[:10] | |
|
r494 | else: | |
pairsIndexList = [] | |||
for pair in pairsList: | |||
if pair not in dataOut.pairsList: | |||
|
r1167 | raise ValueError("Pair %s is not in dataOut.pairsList" %(pair)) | |
|
r494 | pairsIndexList.append(dataOut.pairsList.index(pair)) | |
|
r858 | ||
|
r494 | if pairsIndexList == []: | |
return | |||
|
r858 | ||
|
r1207 | # if len(pairsIndexList) > 4: | |
# pairsIndexList = pairsIndexList[0:4] | |||
|
r760 | ||
hmin_index = None | |||
hmax_index = None | |||
|
r858 | ||
|
r760 | if hmin != None and hmax != None: | |
indexes = numpy.arange(dataOut.nHeights) | |||
hmin_list = indexes[dataOut.heightList >= hmin] | |||
hmax_list = indexes[dataOut.heightList <= hmax] | |||
|
r858 | ||
|
r760 | if hmin_list.any(): | |
hmin_index = hmin_list[0] | |||
|
r858 | ||
|
r760 | if hmax_list.any(): | |
hmax_index = hmax_list[-1]+1 | |||
|
r858 | ||
|
r494 | x = dataOut.getTimeRange() | |
|
r568 | #y = dataOut.getHeiRange() | |
|
r494 | ||
|
r858 | ||
|
r760 | thisDatetime = dataOut.datatime | |
|
r858 | ||
|
r760 | title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y")) | |
|
r494 | xlabel = "Local Time" | |
|
r760 | ylabel = "Phase (degrees)" | |
|
r858 | ||
|
r760 | update_figfile = False | |
|
r858 | ||
|
r494 | nplots = len(pairsIndexList) | |
#phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList))) | |||
phase_beacon = numpy.zeros(len(pairsIndexList)) | |||
for i in range(nplots): | |||
pair = dataOut.pairsList[pairsIndexList[i]] | |||
|
r760 | ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0) | |
powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0) | |||
powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0) | |||
|
r494 | avgcoherenceComplex = ccf/numpy.sqrt(powa*powb) | |
phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi | |||
|
r858 | ||
|
r760 | if dataOut.beacon_heiIndexList: | |
phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList]) | |||
else: | |||
phase_beacon[i] = numpy.average(phase) | |||
|
r858 | ||
|
r760 | if not self.isConfig: | |
|
r858 | ||
|
r494 | nplots = len(pairsIndexList) | |
|
r858 | ||
|
r494 | self.setup(id=id, | |
nplots=nplots, | |||
wintitle=wintitle, | |||
showprofile=showprofile, | |||
show=show) | |||
|
r858 | ||
|
r568 | if timerange != None: | |
self.timerange = timerange | |||
|
r858 | ||
|
r568 | self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange) | |
|
r858 | ||
|
r760 | if ymin == None: ymin = 0 | |
if ymax == None: ymax = 360 | |||
|
r858 | ||
|
r494 | self.FTP_WEI = ftp_wei | |
self.EXP_CODE = exp_code | |||
self.SUB_EXP_CODE = sub_exp_code | |||
self.PLOT_POS = plot_pos | |||
|
r858 | ||
|
r494 | self.name = thisDatetime.strftime("%Y%m%d_%H%M%S") | |
|
r760 | self.isConfig = True | |
|
r494 | self.figfile = figfile | |
self.xdata = numpy.array([]) | |||
self.ydata = numpy.array([]) | |||
|
r858 | ||
|
r760 | update_figfile = True | |
|
r858 | ||
|
r494 | #open file beacon phase | |
path = '%s%03d' %(self.PREFIX, self.id) | |||
beacon_file = os.path.join(path,'%s.txt'%self.name) | |||
self.filename_phase = os.path.join(figpath,beacon_file) | |||
#self.save_phase(self.filename_phase) | |||
|
r858 | ||
|
r494 | #store data beacon phase | |
#self.save_data(self.filename_phase, phase_beacon, thisDatetime) | |||
|
r858 | ||
|
r494 | self.setWinTitle(title) | |
|
r858 | ||
|
r760 | title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S")) | |
|
r858 | ||
|
r760 | legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList] | |
|
r858 | ||
|
r494 | axes = self.axesList[0] | |
|
r858 | ||
|
r494 | self.xdata = numpy.hstack((self.xdata, x[0:1])) | |
|
r858 | ||
|
r494 | if len(self.ydata)==0: | |
self.ydata = phase_beacon.reshape(-1,1) | |||
else: | |||
self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1))) | |||
|
r858 | ||
|
r494 | axes.pmultilineyaxis(x=self.xdata, y=self.ydata, | |
|
r568 | xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, | |
|
r494 | xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid", | |
XAxisAsTime=True, grid='both' | |||
) | |||
|
r858 | ||
|
r494 | self.draw() | |
|
r858 | ||
|
r760 | if dataOut.ltctime >= self.xmax: | |
|
r494 | self.counter_imagwr = wr_period | |
|
r760 | self.isConfig = False | |
update_figfile = True | |||
|
r858 | ||
|
r573 | self.save(figpath=figpath, | |
figfile=figfile, | |||
save=save, | |||
ftp=ftp, | |||
wr_period=wr_period, | |||
thisDatetime=thisDatetime, | |||
|
r1171 | update_figfile=update_figfile) | |
|
r1179 | return dataOut |