##// END OF EJS Templates
schain
RSS
update
rflores -
r1757:522b0e4e76e8
parent child
Show More
Side by Side Unified
Context file:
r1757:522b0e4e76e8 Loading diff...:

The requested changes are too big and content was truncated. Show full diff

Show file before | Show file after | Hide comments
@@ -1,1349 +1,1350
1 1 # Copyright (c) 2012-2021 Jicamarca Radio Observatory
2 2 # All rights reserved.
3 3 #
4 4 # Distributed under the terms of the BSD 3-clause license.
5 5 """Classes to plot Spectra data
6 6
7 7 """
8 8
9 9 import os
10 10 import numpy
11 11 #import collections.abc
12 12
13 13 from schainpy.model.graphics.jroplot_base import Plot, plt, log
14 14
15 15 class SpectraPlot(Plot):
16 16 '''
17 17 Plot for Spectra data
18 18 '''
19 19
20 20 CODE = 'spc'
21 21 colormap = 'jet'
22 22 plot_type = 'pcolor'
23 23 buffering = False
24 24
25 25 def setup(self):
26 26
27 27 self.nplots = len(self.data.channels)
28 28 self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
29 29 self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
30 30 self.height = 2.6 * self.nrows
31 31 self.cb_label = 'dB'
32 32 if self.showprofile:
33 33 self.width = 4 * self.ncols
34 34 else:
35 35 self.width = 3.5 * self.ncols
36 36 self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
37 37 self.ylabel = 'Range [km]'
38 38
39 39 def update(self, dataOut):
40 40
41 41 data = {}
42 42 meta = {}
43 43
44 44 spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
45 45 #print("dataOut.normFactor: ", dataOut.normFactor)
46 46 #print("spc: ", dataOut.data_spc[0,0,0])
47 47 #spc = 10*numpy.log10(dataOut.data_spc)
48 48 #print("Spc: ",spc[0])
49 49 #exit(1)
50 50 data['spc'] = spc
51 51 data['rti'] = dataOut.getPower()
52 52 #print(data['rti'][0])
53 53 #exit(1)
54 54 #print("NormFactor: ",dataOut.normFactor)
55 55 #data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
56 56 if hasattr(dataOut, 'LagPlot'): #Double Pulse
57 57 max_hei_id = dataOut.nHeights - 2*dataOut.LagPlot
58 58 #data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=46,ymax_index=max_hei_id)/dataOut.normFactor)
59 59 #data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=40,ymax_index=max_hei_id)/dataOut.normFactor)
60 60 data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=53,ymax_index=max_hei_id)/dataOut.normFactor)
61 61 data['noise'][0] = 10*numpy.log10(dataOut.getNoise(ymin_index=53)[0]/dataOut.normFactor)
62 62 #data['noise'][1] = 22.035507
63 63 else:
64 64 data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
65 65 #data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=26,ymax_index=44)/dataOut.normFactor)
66 66 meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
67 67
68 68 if self.CODE == 'spc_moments':
69 69 data['moments'] = dataOut.moments
70 70 if self.CODE == 'gaussian_fit':
71 71 data['gaussfit'] = dataOut.DGauFitParams
72 72
73 73 return data, meta
74 74
75 75 def plot(self):
76 76
77 77 if self.xaxis == "frequency":
78 78 x = self.data.xrange[0]
79 79 self.xlabel = "Frequency (kHz)"
80 80 elif self.xaxis == "time":
81 81 x = self.data.xrange[1]
82 82 self.xlabel = "Time (ms)"
83 83 else:
84 84 x = self.data.xrange[2]
85 85 self.xlabel = "Velocity (m/s)"
86 86
87 87 if (self.CODE == 'spc_moments') | (self.CODE == 'gaussian_fit'):
88 88 x = self.data.xrange[2]
89 89 self.xlabel = "Velocity (m/s)"
90 90
91 91 self.titles = []
92 92
93 93 y = self.data.yrange
94 94 self.y = y
95 95
96 96 data = self.data[-1]
97 97 z = data['spc']
98 98
99 99 self.CODE2 = 'spc_oblique'
100 100
101 101 for n, ax in enumerate(self.axes):
102 102 noise = data['noise'][n]
103 103 if self.CODE == 'spc_moments':
104 104 mean = data['moments'][n, 1]
105 105 if self.CODE == 'gaussian_fit':
106 106 gau0 = data['gaussfit'][n][2,:,0]
107 107 gau1 = data['gaussfit'][n][2,:,1]
108 108 if ax.firsttime:
109 109 self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
110 110 self.xmin = self.xmin if self.xmin else numpy.nanmin(x)#-self.xmax
111 111 #self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
112 112 #self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
113 113 if self.zlimits is not None:
114 114 self.zmin, self.zmax = self.zlimits[n]
115 115
116 116 ax.plt = ax.pcolormesh(x, y, z[n].T,
117 117 vmin=self.zmin,
118 118 vmax=self.zmax,
119 119 cmap=plt.get_cmap(self.colormap),
120 120 )
121 121
122 122 if self.showprofile:
123 123 ax.plt_profile = self.pf_axes[n].plot(
124 124 data['rti'][n], y)[0]
125 125 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
126 126 color="k", linestyle="dashed", lw=1)[0]
127 127 if self.CODE == 'spc_moments':
128 128 ax.plt_mean = ax.plot(mean, y, color='k', lw=1)[0]
129 129 if self.CODE == 'gaussian_fit':
130 130 ax.plt_gau0 = ax.plot(gau0, y, color='r', lw=1)[0]
131 131 ax.plt_gau1 = ax.plot(gau1, y, color='y', lw=1)[0]
132 132 else:
133 133 if self.zlimits is not None:
134 134 self.zmin, self.zmax = self.zlimits[n]
135 135 ax.plt.set_array(z[n].T.ravel())
136 136 if self.showprofile:
137 137 ax.plt_profile.set_data(data['rti'][n], y)
138 138 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
139 139 if self.CODE == 'spc_moments':
140 140 ax.plt_mean.set_data(mean, y)
141 141 if self.CODE == 'gaussian_fit':
142 142 ax.plt_gau0.set_data(gau0, y)
143 143 ax.plt_gau1.set_data(gau1, y)
144 144 self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
145 145
146 146 class SpectraObliquePlot(Plot):
147 147 '''
148 148 Plot for Spectra data
149 149 '''
150 150
151 151 CODE = 'spc_oblique'
152 152 colormap = 'jet'
153 153 plot_type = 'pcolor'
154 154
155 155 def setup(self):
156 156 self.xaxis = "oblique"
157 157 self.nplots = len(self.data.channels)
158 158 self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
159 159 self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
160 160 self.height = 2.6 * self.nrows
161 161 self.cb_label = 'dB'
162 162 if self.showprofile:
163 163 self.width = 4 * self.ncols
164 164 else:
165 165 self.width = 3.5 * self.ncols
166 166 self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
167 167 self.ylabel = 'Range [km]'
168 168
169 169 def update(self, dataOut):
170 170
171 171 data = {}
172 172 meta = {}
173 173
174 174 spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
175 175 data['spc'] = spc
176 176 data['rti'] = dataOut.getPower()
177 177 data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
178 178 meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
179 179 '''
180 180 data['shift1'] = dataOut.Oblique_params[0,-2,:]
181 181 data['shift2'] = dataOut.Oblique_params[0,-1,:]
182 182 data['shift1_error'] = dataOut.Oblique_param_errors[0,-2,:]
183 183 data['shift2_error'] = dataOut.Oblique_param_errors[0,-1,:]
184 184 '''
185 185 '''
186 186 data['shift1'] = dataOut.Oblique_params[0,1,:]
187 187 data['shift2'] = dataOut.Oblique_params[0,4,:]
188 188 data['shift1_error'] = dataOut.Oblique_param_errors[0,1,:]
189 189 data['shift2_error'] = dataOut.Oblique_param_errors[0,4,:]
190 190 '''
191 191 data['shift1'] = dataOut.Dop_EEJ_T1[0]
192 192 data['shift2'] = dataOut.Dop_EEJ_T2[0]
193 193 data['max_val_2'] = dataOut.Oblique_params[0,-1,:]
194 194 data['shift1_error'] = dataOut.Err_Dop_EEJ_T1[0]
195 195 data['shift2_error'] = dataOut.Err_Dop_EEJ_T2[0]
196 196
197 197 return data, meta
198 198
199 199 def plot(self):
200 200
201 201 if self.xaxis == "frequency":
202 202 x = self.data.xrange[0]
203 203 self.xlabel = "Frequency (kHz)"
204 204 elif self.xaxis == "time":
205 205 x = self.data.xrange[1]
206 206 self.xlabel = "Time (ms)"
207 207 else:
208 208 x = self.data.xrange[2]
209 209 self.xlabel = "Velocity (m/s)"
210 210
211 211 self.titles = []
212 212
213 213 y = self.data.yrange
214 214 self.y = y
215 215
216 216 data = self.data[-1]
217 217 z = data['spc']
218 218
219 219 for n, ax in enumerate(self.axes):
220 220 noise = self.data['noise'][n][-1]
221 221 shift1 = data['shift1']
222 222 #print(shift1)
223 223 shift2 = data['shift2']
224 224 max_val_2 = data['max_val_2']
225 225 err1 = data['shift1_error']
226 226 err2 = data['shift2_error']
227 227 if ax.firsttime:
228 228
229 229 self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
230 230 self.xmin = self.xmin if self.xmin else -self.xmax
231 231 self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
232 232 self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
233 233 ax.plt = ax.pcolormesh(x, y, z[n].T,
234 234 vmin=self.zmin,
235 235 vmax=self.zmax,
236 236 cmap=plt.get_cmap(self.colormap)
237 237 )
238 238
239 239 if self.showprofile:
240 240 ax.plt_profile = self.pf_axes[n].plot(
241 241 self.data['rti'][n][-1], y)[0]
242 242 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
243 243 color="k", linestyle="dashed", lw=1)[0]
244 244
245 245 self.ploterr1 = ax.errorbar(shift1, y, xerr=err1, fmt='k^', elinewidth=2.2, marker='o', linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
246 246 self.ploterr2 = ax.errorbar(shift2, y, xerr=err2, fmt='m^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
247 247 self.ploterr3 = ax.errorbar(max_val_2, y, xerr=0, fmt='g^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
248 248
249 249 #print("plotter1: ", self.ploterr1,shift1)
250 250
251 251 else:
252 252 #print("else plotter1: ", self.ploterr1,shift1)
253 253 self.ploterr1.remove()
254 254 self.ploterr2.remove()
255 255 self.ploterr3.remove()
256 256 ax.plt.set_array(z[n].T.ravel())
257 257 if self.showprofile:
258 258 ax.plt_profile.set_data(self.data['rti'][n][-1], y)
259 259 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
260 260 self.ploterr1 = ax.errorbar(shift1, y, xerr=err1, fmt='k^', elinewidth=2.2, marker='o', linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
261 261 self.ploterr2 = ax.errorbar(shift2, y, xerr=err2, fmt='m^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
262 262 self.ploterr3 = ax.errorbar(max_val_2, y, xerr=0, fmt='g^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
263 263
264 264 self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
265 265
266 266
267 267 class CrossSpectraPlot(Plot):
268 268
269 269 CODE = 'cspc'
270 270 colormap = 'jet'
271 271 plot_type = 'pcolor'
272 272 zmin_coh = None
273 273 zmax_coh = None
274 274 zmin_phase = None
275 275 zmax_phase = None
276 276
277 277 def setup(self):
278 278
279 279 self.ncols = 4
280 280 self.nplots = len(self.data.pairs) * 2
281 281 self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
282 282 self.width = 3.1 * self.ncols
283 283 self.height = 5 * self.nrows
284 284 self.ylabel = 'Range [km]'
285 285 self.showprofile = False
286 286 self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
287 287
288 288 def update(self, dataOut):
289 289
290 290 data = {}
291 291 meta = {}
292 292
293 293 spc = dataOut.data_spc
294 294 cspc = dataOut.data_cspc
295 295 meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
296 296 meta['pairs'] = dataOut.pairsList
297 297
298 298 tmp = []
299 299
300 300 for n, pair in enumerate(meta['pairs']):
301 301 out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
302 302 coh = numpy.abs(out)
303 303 phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
304 304 tmp.append(coh)
305 305 tmp.append(phase)
306 306
307 307 data['cspc'] = numpy.array(tmp)
308 308
309 309 return data, meta
310 310
311 311 def plot(self):
312 312
313 313 if self.xaxis == "frequency":
314 314 x = self.data.xrange[0]
315 315 self.xlabel = "Frequency (kHz)"
316 316 elif self.xaxis == "time":
317 317 x = self.data.xrange[1]
318 318 self.xlabel = "Time (ms)"
319 319 else:
320 320 x = self.data.xrange[2]
321 321 self.xlabel = "Velocity (m/s)"
322 322
323 323 self.titles = []
324 324
325 325 y = self.data.yrange
326 326 self.y = y
327 327
328 328 data = self.data[-1]
329 329 cspc = data['cspc']
330 330
331 331 for n in range(len(self.data.pairs)):
332 332 pair = self.data.pairs[n]
333 333 coh = cspc[n*2]
334 334 phase = cspc[n*2+1]
335 335 ax = self.axes[2 * n]
336 336 if ax.firsttime:
337 337 ax.plt = ax.pcolormesh(x, y, coh.T,
338 338 vmin=0,
339 339 vmax=1,
340 340 cmap=plt.get_cmap(self.colormap_coh)
341 341 )
342 342 else:
343 343 ax.plt.set_array(coh.T.ravel())
344 344 self.titles.append(
345 345 'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
346 346
347 347 ax = self.axes[2 * n + 1]
348 348 if ax.firsttime:
349 349 ax.plt = ax.pcolormesh(x, y, phase.T,
350 350 vmin=-180,
351 351 vmax=180,
352 352 cmap=plt.get_cmap(self.colormap_phase)
353 353 )
354 354 else:
355 355 ax.plt.set_array(phase.T.ravel())
356 356 self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
357 357
358 358
359 359 class CrossSpectra4Plot(Plot):
360 360
361 361 CODE = 'cspc'
362 362 colormap = 'jet'
363 363 plot_type = 'pcolor'
364 364 zmin_coh = None
365 365 zmax_coh = None
366 366 zmin_phase = None
367 367 zmax_phase = None
368 368
369 369 def setup(self):
370 370
371 371 self.ncols = 4
372 372 self.nrows = len(self.data.pairs)
373 373 self.nplots = self.nrows * 4
374 374 self.width = 3.1 * self.ncols
375 375 self.height = 5 * self.nrows
376 376 self.ylabel = 'Range [km]'
377 377 self.showprofile = False
378 378 self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
379 379
380 380 def plot(self):
381 381
382 382 if self.xaxis == "frequency":
383 383 x = self.data.xrange[0]
384 384 self.xlabel = "Frequency (kHz)"
385 385 elif self.xaxis == "time":
386 386 x = self.data.xrange[1]
387 387 self.xlabel = "Time (ms)"
388 388 else:
389 389 x = self.data.xrange[2]
390 390 self.xlabel = "Velocity (m/s)"
391 391
392 392 self.titles = []
393 393
394 394
395 395 y = self.data.heights
396 396 self.y = y
397 397 nspc = self.data['spc']
398 398 #print(numpy.shape(self.data['spc']))
399 399 spc = self.data['cspc'][0]
400 400 #print(numpy.shape(nspc))
401 401 #exit()
402 402 #nspc[1,:,:] = numpy.flip(nspc[1,:,:],axis=0)
403 403 #print(numpy.shape(spc))
404 404 #exit()
405 405 cspc = self.data['cspc'][1]
406 406
407 407 #xflip=numpy.flip(x)
408 408 #print(numpy.shape(cspc))
409 409 #exit()
410 410
411 411 for n in range(self.nrows):
412 412 noise = self.data['noise'][:,-1]
413 413 pair = self.data.pairs[n]
414 414 #print(pair)
415 415 #exit()
416 416 ax = self.axes[4 * n]
417 417 if ax.firsttime:
418 418 self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
419 419 self.xmin = self.xmin if self.xmin else -self.xmax
420 420 self.zmin = self.zmin if self.zmin else numpy.nanmin(nspc)
421 421 self.zmax = self.zmax if self.zmax else numpy.nanmax(nspc)
422 422 ax.plt = ax.pcolormesh(x , y , nspc[pair[0]].T,
423 423 vmin=self.zmin,
424 424 vmax=self.zmax,
425 425 cmap=plt.get_cmap(self.colormap)
426 426 )
427 427 else:
428 428 #print(numpy.shape(nspc[pair[0]].T))
429 429 #exit()
430 430 ax.plt.set_array(nspc[pair[0]].T.ravel())
431 431 self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise[pair[0]]))
432 432
433 433 ax = self.axes[4 * n + 1]
434 434
435 435 if ax.firsttime:
436 436 ax.plt = ax.pcolormesh(x , y, numpy.flip(nspc[pair[1]],axis=0).T,
437 437 vmin=self.zmin,
438 438 vmax=self.zmax,
439 439 cmap=plt.get_cmap(self.colormap)
440 440 )
441 441 else:
442 442
443 443 ax.plt.set_array(numpy.flip(nspc[pair[1]],axis=0).T.ravel())
444 444 self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise[pair[1]]))
445 445
446 446 out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
447 447 coh = numpy.abs(out)
448 448 phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
449 449
450 450 ax = self.axes[4 * n + 2]
451 451 if ax.firsttime:
452 452 ax.plt = ax.pcolormesh(x, y, numpy.flip(coh,axis=0).T,
453 453 vmin=0,
454 454 vmax=1,
455 455 cmap=plt.get_cmap(self.colormap_coh)
456 456 )
457 457 else:
458 458 ax.plt.set_array(numpy.flip(coh,axis=0).T.ravel())
459 459 self.titles.append(
460 460 'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
461 461
462 462 ax = self.axes[4 * n + 3]
463 463 if ax.firsttime:
464 464 ax.plt = ax.pcolormesh(x, y, numpy.flip(phase,axis=0).T,
465 465 vmin=-180,
466 466 vmax=180,
467 467 cmap=plt.get_cmap(self.colormap_phase)
468 468 )
469 469 else:
470 470 ax.plt.set_array(numpy.flip(phase,axis=0).T.ravel())
471 471 self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
472 472
473 473
474 474 class CrossSpectra2Plot(Plot):
475 475
476 476 CODE = 'cspc'
477 477 colormap = 'jet'
478 478 plot_type = 'pcolor'
479 479 zmin_coh = None
480 480 zmax_coh = None
481 481 zmin_phase = None
482 482 zmax_phase = None
483 483
484 484 def setup(self):
485 485
486 486 self.ncols = 1
487 487 self.nrows = len(self.data.pairs)
488 488 self.nplots = self.nrows * 1
489 489 self.width = 3.1 * self.ncols
490 490 self.height = 5 * self.nrows
491 491 self.ylabel = 'Range [km]'
492 492 self.showprofile = False
493 493 self.plots_adjust.update({'left': 0.22, 'right': .90, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
494 494
495 495 def plot(self):
496 496
497 497 if self.xaxis == "frequency":
498 498 x = self.data.xrange[0]
499 499 self.xlabel = "Frequency (kHz)"
500 500 elif self.xaxis == "time":
501 501 x = self.data.xrange[1]
502 502 self.xlabel = "Time (ms)"
503 503 else:
504 504 x = self.data.xrange[2]
505 505 self.xlabel = "Velocity (m/s)"
506 506
507 507 self.titles = []
508 508
509 509
510 510 y = self.data.heights
511 511 self.y = y
512 512 #nspc = self.data['spc']
513 513 #print(numpy.shape(self.data['spc']))
514 514 #spc = self.data['cspc'][0]
515 515 #print(numpy.shape(spc))
516 516 #exit()
517 517 cspc = self.data['cspc'][1]
518 518 #print(numpy.shape(cspc))
519 519 #exit()
520 520
521 521 for n in range(self.nrows):
522 522 noise = self.data['noise'][:,-1]
523 523 pair = self.data.pairs[n]
524 524 #print(pair) #exit()
525 525
526 526
527 527
528 528 out = cspc[n]# / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
529 529
530 530 #print(out[:,53])
531 531 #exit()
532 532 cross = numpy.abs(out)
533 533 z = cross/self.data.nFactor
534 534 #print("here")
535 535 #print(dataOut.data_spc[0,0,0])
536 536 #exit()
537 537
538 538 cross = 10*numpy.log10(z)
539 539 #print(numpy.shape(cross))
540 540 #print(cross[0,:])
541 541 #print(self.data.nFactor)
542 542 #exit()
543 543 #phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
544 544
545 545 ax = self.axes[1 * n]
546 546 if ax.firsttime:
547 547 self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
548 548 self.xmin = self.xmin if self.xmin else -self.xmax
549 549 self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
550 550 self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
551 551 ax.plt = ax.pcolormesh(x, y, cross.T,
552 552 vmin=self.zmin,
553 553 vmax=self.zmax,
554 554 cmap=plt.get_cmap(self.colormap)
555 555 )
556 556 else:
557 557 ax.plt.set_array(cross.T.ravel())
558 558 self.titles.append(
559 559 'Cross Spectra Power Ch{} * Ch{}'.format(pair[0], pair[1]))
560 560
561 561
562 562 class CrossSpectra3Plot(Plot):
563 563
564 564 CODE = 'cspc'
565 565 colormap = 'jet'
566 566 plot_type = 'pcolor'
567 567 zmin_coh = None
568 568 zmax_coh = None
569 569 zmin_phase = None
570 570 zmax_phase = None
571 571
572 572 def setup(self):
573 573
574 574 self.ncols = 3
575 575 self.nrows = len(self.data.pairs)
576 576 self.nplots = self.nrows * 3
577 577 self.width = 3.1 * self.ncols
578 578 self.height = 5 * self.nrows
579 579 self.ylabel = 'Range [km]'
580 580 self.showprofile = False
581 581 self.plots_adjust.update({'left': 0.22, 'right': .90, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
582 582
583 583 def plot(self):
584 584
585 585 if self.xaxis == "frequency":
586 586 x = self.data.xrange[0]
587 587 self.xlabel = "Frequency (kHz)"
588 588 elif self.xaxis == "time":
589 589 x = self.data.xrange[1]
590 590 self.xlabel = "Time (ms)"
591 591 else:
592 592 x = self.data.xrange[2]
593 593 self.xlabel = "Velocity (m/s)"
594 594
595 595 self.titles = []
596 596
597 597
598 598 y = self.data.heights
599 599 self.y = y
600 600 #nspc = self.data['spc']
601 601 #print(numpy.shape(self.data['spc']))
602 602 #spc = self.data['cspc'][0]
603 603 #print(numpy.shape(spc))
604 604 #exit()
605 605 cspc = self.data['cspc'][1]
606 606 #print(numpy.shape(cspc))
607 607 #exit()
608 608
609 609 for n in range(self.nrows):
610 610 noise = self.data['noise'][:,-1]
611 611 pair = self.data.pairs[n]
612 612 #print(pair) #exit()
613 613
614 614
615 615
616 616 out = cspc[n]# / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
617 617
618 618 #print(out[:,53])
619 619 #exit()
620 620 cross = numpy.abs(out)
621 621 z = cross/self.data.nFactor
622 622 cross = 10*numpy.log10(z)
623 623
624 624 out_r= out.real/self.data.nFactor
625 625 #out_r = 10*numpy.log10(out_r)
626 626
627 627 out_i= out.imag/self.data.nFactor
628 628 #out_i = 10*numpy.log10(out_i)
629 629 #print(numpy.shape(cross))
630 630 #print(cross[0,:])
631 631 #print(self.data.nFactor)
632 632 #exit()
633 633 #phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
634 634
635 635 ax = self.axes[3 * n]
636 636 if ax.firsttime:
637 637 self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
638 638 self.xmin = self.xmin if self.xmin else -self.xmax
639 639 self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
640 640 self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
641 641 ax.plt = ax.pcolormesh(x, y, cross.T,
642 642 vmin=self.zmin,
643 643 vmax=self.zmax,
644 644 cmap=plt.get_cmap(self.colormap)
645 645 )
646 646 else:
647 647 ax.plt.set_array(cross.T.ravel())
648 648 self.titles.append(
649 649 'Cross Spectra Power Ch{} * Ch{}'.format(pair[0], pair[1]))
650 650
651 651 ax = self.axes[3 * n + 1]
652 652 if ax.firsttime:
653 653 self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
654 654 self.xmin = self.xmin if self.xmin else -self.xmax
655 655 self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
656 656 self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
657 657 ax.plt = ax.pcolormesh(x, y, out_r.T,
658 658 vmin=-1.e6,
659 659 vmax=0,
660 660 cmap=plt.get_cmap(self.colormap)
661 661 )
662 662 else:
663 663 ax.plt.set_array(out_r.T.ravel())
664 664 self.titles.append(
665 665 'Cross Spectra Real Ch{} * Ch{}'.format(pair[0], pair[1]))
666 666
667 667 ax = self.axes[3 * n + 2]
668 668
669 669
670 670 if ax.firsttime:
671 671 self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
672 672 self.xmin = self.xmin if self.xmin else -self.xmax
673 673 self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
674 674 self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
675 675 ax.plt = ax.pcolormesh(x, y, out_i.T,
676 676 vmin=-1.e6,
677 677 vmax=1.e6,
678 678 cmap=plt.get_cmap(self.colormap)
679 679 )
680 680 else:
681 681 ax.plt.set_array(out_i.T.ravel())
682 682 self.titles.append(
683 683 'Cross Spectra Imag Ch{} * Ch{}'.format(pair[0], pair[1]))
684 684
685 685 class RTIPlot(Plot):
686 686 '''
687 687 Plot for RTI data
688 688 '''
689 689
690 690 CODE = 'rti'
691 691 colormap = 'jet'
692 692 plot_type = 'pcolorbuffer'
693 693
694 694 def setup(self):
695 695 self.xaxis = 'time'
696 696 self.ncols = 1
697 697 self.nrows = len(self.data.channels)
698 698 self.nplots = len(self.data.channels)
699 699 self.ylabel = 'Range [km]'
700 700 self.xlabel = 'Time'
701 701 self.cb_label = 'dB'
702 702 self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
703 703 self.titles = ['{} Channel {}'.format(
704 704 self.CODE.upper(), x) for x in range(self.nrows)]
705 705
706 706 def update(self, dataOut):
707 707
708 708 data = {}
709 709 meta = {}
710 710 data['rti'] = dataOut.getPower()
711 711 #print(numpy.shape(data['rti']))
712 712
713 713 data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
714 714
715 715 return data, meta
716 716
717 717 def plot(self):
718 718
719 719 self.x = self.data.times
720 720 self.y = self.data.yrange
721 721 self.z = self.data[self.CODE]
722 722 #print("Inside RTI: ", self.z)
723 723 self.z = numpy.ma.masked_invalid(self.z)
724 724
725 725 if self.decimation is None:
726 726 x, y, z = self.fill_gaps(self.x, self.y, self.z)
727 727 else:
728 728 x, y, z = self.fill_gaps(*self.decimate())
729 729 #print("self.z: ", self.z)
730 730 #exit(1)
731 731 '''
732 732 if not isinstance(self.zmin, collections.abc.Sequence):
733 733 if not self.zmin:
734 734 self.zmin = [numpy.min(self.z)]*len(self.axes)
735 735 else:
736 736 self.zmin = [self.zmin]*len(self.axes)
737 737
738 738 if not isinstance(self.zmax, collections.abc.Sequence):
739 739 if not self.zmax:
740 740 self.zmax = [numpy.max(self.z)]*len(self.axes)
741 741 else:
742 742 self.zmax = [self.zmax]*len(self.axes)
743 743 '''
744 744 for n, ax in enumerate(self.axes):
745 745
746 746 self.zmin = self.zmin if self.zmin else numpy.min(self.z)
747 747 self.zmax = self.zmax if self.zmax else numpy.max(self.z)
748 748
749 749 if ax.firsttime:
750 750 if self.zlimits is not None:
751 751 self.zmin, self.zmax = self.zlimits[n]
752 752 ax.plt = ax.pcolormesh(x, y, z[n].T,
753 753 vmin=self.zmin,
754 754 vmax=self.zmax,
755 755 cmap=plt.get_cmap(self.colormap)
756 756 )
757 757 if self.showprofile:
758 758 ax.plot_profile = self.pf_axes[n].plot(
759 759 self.data['rti'][n][-1], self.y)[0]
760 760 ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
761 761 color="k", linestyle="dashed", lw=1)[0]
762 762 else:
763 763 if self.zlimits is not None:
764 764 self.zmin, self.zmax = self.zlimits[n]
765 765 ax.plt.remove()
766 766 ax.plt = ax.pcolormesh(x, y, z[n].T,
767 767 vmin=self.zmin,
768 768 vmax=self.zmax,
769 769 cmap=plt.get_cmap(self.colormap)
770 770 )
771 771 if self.showprofile:
772 772 ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
773 773 ax.plot_noise.set_data(numpy.repeat(
774 774 self.data['noise'][n][-1], len(self.y)), self.y)
775 775
776 776
777 777 class SpectrogramPlot(Plot):
778 778 '''
779 779 Plot for Spectrogram data
780 780 '''
781 781
782 782 CODE = 'Spectrogram_Profile'
783 783 colormap = 'binary'
784 784 plot_type = 'pcolorbuffer'
785 785
786 786 def setup(self):
787 787 self.xaxis = 'time'
788 788 self.ncols = 1
789 789 self.nrows = len(self.data.channels)
790 790 self.nplots = len(self.data.channels)
791 791 self.xlabel = 'Time'
792 792 #self.cb_label = 'dB'
793 793 self.plots_adjust.update({'hspace':1.2, 'left': 0.1, 'bottom': 0.12, 'right':0.95})
794 794 self.titles = []
795 795
796 796 #self.titles = ['{} Channel {} \n H = {} km ({} - {})'.format(
797 797 #self.CODE.upper(), x, self.data.heightList[self.data.hei], self.data.heightList[self.data.hei],self.data.heightList[self.data.hei]+(self.data.DH*self.data.nProfiles)) for x in range(self.nrows)]
798 798
799 799 self.titles = ['{} Channel {}'.format(
800 800 self.CODE.upper(), x) for x in range(self.nrows)]
801 801
802 802
803 803 def update(self, dataOut):
804 804 data = {}
805 805 meta = {}
806 806
807 807 maxHei = 1620#+12000
808 808 maxHei = 1180
809 maxHei = 500
809 810 indb = numpy.where(dataOut.heightList <= maxHei)
810 811 hei = indb[0][-1]
811 812 #print(dataOut.heightList)
812 813
813 814 factor = dataOut.nIncohInt
814 815 z = dataOut.data_spc[:,:,hei] / factor
815 816 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
816 817 #buffer = 10 * numpy.log10(z)
817 818
818 819 meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
819 820
820 821
821 822 #self.hei = hei
822 823 #self.heightList = dataOut.heightList
823 824 #self.DH = (dataOut.heightList[1] - dataOut.heightList[0])/dataOut.step
824 825 #self.nProfiles = dataOut.nProfiles
825 826
826 827 data['Spectrogram_Profile'] = 10 * numpy.log10(z)
827 828
828 829 data['hei'] = hei
829 830 data['DH'] = (dataOut.heightList[1] - dataOut.heightList[0])/dataOut.step
830 831 data['nProfiles'] = dataOut.nProfiles
831 832 #meta['yrange'] = dataOut.heightList[0:dataOut.NSHTS]
832 833 '''
833 834 import matplotlib.pyplot as plt
834 835 plt.plot(10 * numpy.log10(z[0,:]))
835 836 plt.show()
836 837
837 838 from time import sleep
838 839 sleep(10)
839 840 '''
840 841 return data, meta
841 842
842 843 def plot(self):
843 844
844 845 self.x = self.data.times
845 846 self.z = self.data[self.CODE]
846 847 self.y = self.data.xrange[0]
847 848
848 849 hei = self.data['hei'][-1]
849 850 DH = self.data['DH'][-1]
850 851 nProfiles = self.data['nProfiles'][-1]
851 852
852 853 self.ylabel = "Frequency (kHz)"
853 854
854 855 self.z = numpy.ma.masked_invalid(self.z)
855 856
856 857 if self.decimation is None:
857 858 x, y, z = self.fill_gaps(self.x, self.y, self.z)
858 859 else:
859 860 x, y, z = self.fill_gaps(*self.decimate())
860 861
861 862 for n, ax in enumerate(self.axes):
862 863 self.zmin = self.zmin if self.zmin else numpy.min(self.z)
863 864 self.zmax = self.zmax if self.zmax else numpy.max(self.z)
864 865 data = self.data[-1]
865 866 if ax.firsttime:
866 867 ax.plt = ax.pcolormesh(x, y, z[n].T,
867 868 vmin=self.zmin,
868 869 vmax=self.zmax,
869 870 cmap=plt.get_cmap(self.colormap)
870 871 )
871 872 else:
872 873 ax.plt.remove()
873 874 ax.plt = ax.pcolormesh(x, y, z[n].T,
874 875 vmin=self.zmin,
875 876 vmax=self.zmax,
876 877 cmap=plt.get_cmap(self.colormap)
877 878 )
878 879
879 880 #self.titles.append('Spectrogram')
880 881
881 882 #self.titles.append('{} Channel {} \n H = {} km ({} - {})'.format(
882 883 #self.CODE.upper(), x, y[hei], y[hei],y[hei]+(DH*nProfiles)))
883 884
884 885
885 886
886 887
887 888 class CoherencePlot(RTIPlot):
888 889 '''
889 890 Plot for Coherence data
890 891 '''
891 892
892 893 CODE = 'coh'
893 894
894 895 def setup(self):
895 896 self.xaxis = 'time'
896 897 self.ncols = 1
897 898 self.nrows = len(self.data.pairs)
898 899 self.nplots = len(self.data.pairs)
899 900 self.ylabel = 'Range [km]'
900 901 self.xlabel = 'Time'
901 902 self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1,'right':0.95})
902 903 if self.CODE == 'coh':
903 904 self.cb_label = ''
904 905 self.titles = [
905 906 'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
906 907 else:
907 908 self.cb_label = 'Degrees'
908 909 self.titles = [
909 910 'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
910 911
911 912 def update(self, dataOut):
912 913
913 914 data = {}
914 915 meta = {}
915 916 data['coh'] = dataOut.getCoherence()
916 917 meta['pairs'] = dataOut.pairsList
917 918
918 919 return data, meta
919 920
920 921 class PhasePlot(CoherencePlot):
921 922 '''
922 923 Plot for Phase map data
923 924 '''
924 925
925 926 CODE = 'phase'
926 927 colormap = 'seismic'
927 928
928 929 def update(self, dataOut):
929 930
930 931 data = {}
931 932 meta = {}
932 933 data['phase'] = dataOut.getCoherence(phase=True)
933 934 meta['pairs'] = dataOut.pairsList
934 935
935 936 return data, meta
936 937
937 938 class NoisePlot(Plot):
938 939 '''
939 940 Plot for noise
940 941 '''
941 942
942 943 CODE = 'noise'
943 944 plot_type = 'scatterbuffer'
944 945
945 946 def setup(self):
946 947 self.xaxis = 'time'
947 948 self.ncols = 1
948 949 self.nrows = 1
949 950 self.nplots = 1
950 951 self.ylabel = 'Intensity [dB]'
951 952 self.xlabel = 'Time'
952 953 self.titles = ['Noise']
953 954 self.colorbar = False
954 955 self.plots_adjust.update({'right': 0.85 })
955 956
956 957 def update(self, dataOut):
957 958
958 959 data = {}
959 960 meta = {}
960 961 data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor).reshape(dataOut.nChannels, 1)
961 962 meta['yrange'] = numpy.array([])
962 963
963 964 return data, meta
964 965
965 966 def plot(self):
966 967
967 968 x = self.data.times
968 969 xmin = self.data.min_time
969 970 xmax = xmin + self.xrange * 60 * 60
970 971 Y = self.data['noise']
971 972
972 973 if self.axes[0].firsttime:
973 974 self.ymin = numpy.nanmin(Y) - 5
974 975 self.ymax = numpy.nanmax(Y) + 5
975 976 for ch in self.data.channels:
976 977 y = Y[ch]
977 978 self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
978 979 plt.legend(bbox_to_anchor=(1.18, 1.0))
979 980 else:
980 981 for ch in self.data.channels:
981 982 y = Y[ch]
982 983 self.axes[0].lines[ch].set_data(x, y)
983 984
984 985 self.ymin = numpy.nanmin(Y) - 5
985 986 self.ymax = numpy.nanmax(Y) + 10
986 987
987 988
988 989 class PowerProfilePlot(Plot):
989 990
990 991 CODE = 'pow_profile'
991 992 plot_type = 'scatter'
992 993
993 994 def setup(self):
994 995
995 996 self.ncols = 1
996 997 self.nrows = 1
997 998 self.nplots = 1
998 999 self.height = 4
999 1000 self.width = 3
1000 1001 self.ylabel = 'Range [km]'
1001 1002 self.xlabel = 'Intensity [dB]'
1002 1003 self.titles = ['Power Profile']
1003 1004 self.colorbar = False
1004 1005
1005 1006 def update(self, dataOut):
1006 1007
1007 1008 data = {}
1008 1009 meta = {}
1009 1010 data[self.CODE] = dataOut.getPower()
1010 1011
1011 1012 return data, meta
1012 1013
1013 1014 def plot(self):
1014 1015
1015 1016 y = self.data.yrange
1016 1017 self.y = y
1017 1018
1018 1019 x = self.data[-1][self.CODE]
1019 1020
1020 1021 if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9
1021 1022 if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1
1022 1023
1023 1024 if self.axes[0].firsttime:
1024 1025 for ch in self.data.channels:
1025 1026 self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch))
1026 1027 plt.legend()
1027 1028 else:
1028 1029 for ch in self.data.channels:
1029 1030 self.axes[0].lines[ch].set_data(x[ch], y)
1030 1031
1031 1032
1032 1033 class SpectraCutPlot(Plot):
1033 1034
1034 1035 CODE = 'spc_cut'
1035 1036 plot_type = 'scatter'
1036 1037 buffering = False
1037 1038
1038 1039 def setup(self):
1039 1040
1040 1041 self.nplots = len(self.data.channels)
1041 1042 self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
1042 1043 self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
1043 1044 self.width = 3.4 * self.ncols + 1.5
1044 1045 self.height = 3 * self.nrows
1045 1046 self.ylabel = 'Power [dB]'
1046 1047 self.colorbar = False
1047 1048 self.plots_adjust.update({'left':0.1, 'hspace':0.3, 'right': 0.75, 'bottom':0.08})
1048 1049
1049 1050 def update(self, dataOut):
1050 1051
1051 1052 data = {}
1052 1053 meta = {}
1053 1054 spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
1054 1055 data['spc'] = spc
1055 1056 meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
1056 1057 if self.CODE == 'cut_gaussian_fit':
1057 1058 data['gauss_fit0'] = 10*numpy.log10(dataOut.GaussFit0/dataOut.normFactor)
1058 1059 data['gauss_fit1'] = 10*numpy.log10(dataOut.GaussFit1/dataOut.normFactor)
1059 1060 return data, meta
1060 1061
1061 1062 def plot(self):
1062 1063 if self.xaxis == "frequency":
1063 1064 x = self.data.xrange[0][1:]
1064 1065 self.xlabel = "Frequency (kHz)"
1065 1066 elif self.xaxis == "time":
1066 1067 x = self.data.xrange[1]
1067 1068 self.xlabel = "Time (ms)"
1068 1069 else:
1069 1070 x = self.data.xrange[2][:-1]
1070 1071 self.xlabel = "Velocity (m/s)"
1071 1072
1072 1073 if self.CODE == 'cut_gaussian_fit':
1073 1074 x = self.data.xrange[2][:-1]
1074 1075 self.xlabel = "Velocity (m/s)"
1075 1076
1076 1077 self.titles = []
1077 1078
1078 1079 y = self.data.yrange
1079 1080 data = self.data[-1]
1080 1081 z = data['spc']
1081 1082
1082 1083 if self.height_index:
1083 1084 index = numpy.array(self.height_index)
1084 1085 else:
1085 1086 index = numpy.arange(0, len(y), int((len(y))/9))
1086 1087
1087 1088 for n, ax in enumerate(self.axes):
1088 1089 if self.CODE == 'cut_gaussian_fit':
1089 1090 gau0 = data['gauss_fit0']
1090 1091 gau1 = data['gauss_fit1']
1091 1092 if ax.firsttime:
1092 1093 self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
1093 1094 self.xmin = self.xmin if self.xmin else -self.xmax
1094 1095 self.ymin = self.ymin if self.ymin else numpy.nanmin(z[:,:,index])
1095 1096 self.ymax = self.ymax if self.ymax else numpy.nanmax(z[:,:,index])
1096 1097 #print(self.ymax)
1097 1098 #print(z[n, :, index])
1098 1099 ax.plt = ax.plot(x, z[n, :, index].T, lw=0.25)
1099 1100 if self.CODE == 'cut_gaussian_fit':
1100 1101 ax.plt_gau0 = ax.plot(x, gau0[n, :, index].T, lw=1, linestyle='-.')
1101 1102 for i, line in enumerate(ax.plt_gau0):
1102 1103 line.set_color(ax.plt[i].get_color())
1103 1104 ax.plt_gau1 = ax.plot(x, gau1[n, :, index].T, lw=1, linestyle='--')
1104 1105 for i, line in enumerate(ax.plt_gau1):
1105 1106 line.set_color(ax.plt[i].get_color())
1106 1107 labels = ['Range = {:2.1f}km'.format(y[i]) for i in index]
1107 1108 self.figures[0].legend(ax.plt, labels, loc='center right')
1108 1109 else:
1109 1110 for i, line in enumerate(ax.plt):
1110 1111 line.set_data(x, z[n, :, index[i]].T)
1111 1112 for i, line in enumerate(ax.plt_gau0):
1112 1113 line.set_data(x, gau0[n, :, index[i]].T)
1113 1114 line.set_color(ax.plt[i].get_color())
1114 1115 for i, line in enumerate(ax.plt_gau1):
1115 1116 line.set_data(x, gau1[n, :, index[i]].T)
1116 1117 line.set_color(ax.plt[i].get_color())
1117 1118 self.titles.append('CH {}'.format(n))
1118 1119
1119 1120
1120 1121 class BeaconPhase(Plot):
1121 1122
1122 1123 __isConfig = None
1123 1124 __nsubplots = None
1124 1125
1125 1126 PREFIX = 'beacon_phase'
1126 1127
1127 1128 def __init__(self):
1128 1129 Plot.__init__(self)
1129 1130 self.timerange = 24*60*60
1130 1131 self.isConfig = False
1131 1132 self.__nsubplots = 1
1132 1133 self.counter_imagwr = 0
1133 1134 self.WIDTH = 800
1134 1135 self.HEIGHT = 400
1135 1136 self.WIDTHPROF = 120
1136 1137 self.HEIGHTPROF = 0
1137 1138 self.xdata = None
1138 1139 self.ydata = None
1139 1140
1140 1141 self.PLOT_CODE = BEACON_CODE
1141 1142
1142 1143 self.FTP_WEI = None
1143 1144 self.EXP_CODE = None
1144 1145 self.SUB_EXP_CODE = None
1145 1146 self.PLOT_POS = None
1146 1147
1147 1148 self.filename_phase = None
1148 1149
1149 1150 self.figfile = None
1150 1151
1151 1152 self.xmin = None
1152 1153 self.xmax = None
1153 1154
1154 1155 def getSubplots(self):
1155 1156
1156 1157 ncol = 1
1157 1158 nrow = 1
1158 1159
1159 1160 return nrow, ncol
1160 1161
1161 1162 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1162 1163
1163 1164 self.__showprofile = showprofile
1164 1165 self.nplots = nplots
1165 1166
1166 1167 ncolspan = 7
1167 1168 colspan = 6
1168 1169 self.__nsubplots = 2
1169 1170
1170 1171 self.createFigure(id = id,
1171 1172 wintitle = wintitle,
1172 1173 widthplot = self.WIDTH+self.WIDTHPROF,
1173 1174 heightplot = self.HEIGHT+self.HEIGHTPROF,
1174 1175 show=show)
1175 1176
1176 1177 nrow, ncol = self.getSubplots()
1177 1178
1178 1179 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1179 1180
1180 1181 def save_phase(self, filename_phase):
1181 1182 f = open(filename_phase,'w+')
1182 1183 f.write('\n\n')
1183 1184 f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
1184 1185 f.write('DD MM YYYY HH MM SS pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
1185 1186 f.close()
1186 1187
1187 1188 def save_data(self, filename_phase, data, data_datetime):
1188 1189 f=open(filename_phase,'a')
1189 1190 timetuple_data = data_datetime.timetuple()
1190 1191 day = str(timetuple_data.tm_mday)
1191 1192 month = str(timetuple_data.tm_mon)
1192 1193 year = str(timetuple_data.tm_year)
1193 1194 hour = str(timetuple_data.tm_hour)
1194 1195 minute = str(timetuple_data.tm_min)
1195 1196 second = str(timetuple_data.tm_sec)
1196 1197 f.write(day+' '+month+' '+year+' '+hour+' '+minute+' '+second+' '+str(data[0])+' '+str(data[1])+' '+str(data[2])+' '+str(data[3])+'\n')
1197 1198 f.close()
1198 1199
1199 1200 def plot(self):
1200 1201 log.warning('TODO: Not yet implemented...')
1201 1202
1202 1203 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
1203 1204 xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
1204 1205 timerange=None,
1205 1206 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
1206 1207 server=None, folder=None, username=None, password=None,
1207 1208 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1208 1209
1209 1210 if dataOut.flagNoData:
1210 1211 return dataOut
1211 1212
1212 1213 if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
1213 1214 return
1214 1215
1215 1216 if pairsList == None:
1216 1217 pairsIndexList = dataOut.pairsIndexList[:10]
1217 1218 else:
1218 1219 pairsIndexList = []
1219 1220 for pair in pairsList:
1220 1221 if pair not in dataOut.pairsList:
1221 1222 raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
1222 1223 pairsIndexList.append(dataOut.pairsList.index(pair))
1223 1224
1224 1225 if pairsIndexList == []:
1225 1226 return
1226 1227
1227 1228 # if len(pairsIndexList) > 4:
1228 1229 # pairsIndexList = pairsIndexList[0:4]
1229 1230
1230 1231 hmin_index = None
1231 1232 hmax_index = None
1232 1233
1233 1234 if hmin != None and hmax != None:
1234 1235 indexes = numpy.arange(dataOut.nHeights)
1235 1236 hmin_list = indexes[dataOut.heightList >= hmin]
1236 1237 hmax_list = indexes[dataOut.heightList <= hmax]
1237 1238
1238 1239 if hmin_list.any():
1239 1240 hmin_index = hmin_list[0]
1240 1241
1241 1242 if hmax_list.any():
1242 1243 hmax_index = hmax_list[-1]+1
1243 1244
1244 1245 x = dataOut.getTimeRange()
1245 1246
1246 1247 thisDatetime = dataOut.datatime
1247 1248
1248 1249 title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
1249 1250 xlabel = "Local Time"
1250 1251 ylabel = "Phase (degrees)"
1251 1252
1252 1253 update_figfile = False
1253 1254
1254 1255 nplots = len(pairsIndexList)
1255 1256 #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
1256 1257 phase_beacon = numpy.zeros(len(pairsIndexList))
1257 1258 for i in range(nplots):
1258 1259 pair = dataOut.pairsList[pairsIndexList[i]]
1259 1260 ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
1260 1261 powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
1261 1262 powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
1262 1263 avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
1263 1264 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
1264 1265
1265 1266 if dataOut.beacon_heiIndexList:
1266 1267 phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
1267 1268 else:
1268 1269 phase_beacon[i] = numpy.average(phase)
1269 1270
1270 1271 if not self.isConfig:
1271 1272
1272 1273 nplots = len(pairsIndexList)
1273 1274
1274 1275 self.setup(id=id,
1275 1276 nplots=nplots,
1276 1277 wintitle=wintitle,
1277 1278 showprofile=showprofile,
1278 1279 show=show)
1279 1280
1280 1281 if timerange != None:
1281 1282 self.timerange = timerange
1282 1283
1283 1284 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
1284 1285
1285 1286 if ymin == None: ymin = 0
1286 1287 if ymax == None: ymax = 360
1287 1288
1288 1289 self.FTP_WEI = ftp_wei
1289 1290 self.EXP_CODE = exp_code
1290 1291 self.SUB_EXP_CODE = sub_exp_code
1291 1292 self.PLOT_POS = plot_pos
1292 1293
1293 1294 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1294 1295 self.isConfig = True
1295 1296 self.figfile = figfile
1296 1297 self.xdata = numpy.array([])
1297 1298 self.ydata = numpy.array([])
1298 1299
1299 1300 update_figfile = True
1300 1301
1301 1302 #open file beacon phase
1302 1303 path = '%s%03d' %(self.PREFIX, self.id)
1303 1304 beacon_file = os.path.join(path,'%s.txt'%self.name)
1304 1305 self.filename_phase = os.path.join(figpath,beacon_file)
1305 1306 #self.save_phase(self.filename_phase)
1306 1307
1307 1308
1308 1309 #store data beacon phase
1309 1310 #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
1310 1311
1311 1312 self.setWinTitle(title)
1312 1313
1313 1314
1314 1315 title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1315 1316
1316 1317 legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
1317 1318
1318 1319 axes = self.axesList[0]
1319 1320
1320 1321 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1321 1322
1322 1323 if len(self.ydata)==0:
1323 1324 self.ydata = phase_beacon.reshape(-1,1)
1324 1325 else:
1325 1326 self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
1326 1327
1327 1328
1328 1329 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1329 1330 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
1330 1331 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1331 1332 XAxisAsTime=True, grid='both'
1332 1333 )
1333 1334
1334 1335 self.draw()
1335 1336
1336 1337 if dataOut.ltctime >= self.xmax:
1337 1338 self.counter_imagwr = wr_period
1338 1339 self.isConfig = False
1339 1340 update_figfile = True
1340 1341
1341 1342 self.save(figpath=figpath,
1342 1343 figfile=figfile,
1343 1344 save=save,
1344 1345 ftp=ftp,
1345 1346 wr_period=wr_period,
1346 1347 thisDatetime=thisDatetime,
1347 1348 update_figfile=update_figfile)
1348 1349
1349 1350 return dataOut
Show file before | Show file after | Hide comments
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
Show file before | Show file after | Hide comments
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
General Comments 0
You need to be logged in to leave comments. Login now