##// END OF EJS Templates
schain
RSS
15/3/18
ebocanegra -
r1149:c513dba92d21
parent child
Show More
Side by Side Unified
Context file:
r1149:c513dba92d21 Loading diff...:

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

Show file before | Show file after | Hide comments
@@ -1,2160 +1,2161
1 1 import os
2 2 import datetime
3 3 import numpy
4 4 import inspect
5 5 from figure import Figure, isRealtime, isTimeInHourRange
6 6 from plotting_codes import *
7 7
8 8
9 9 class SpcParamPlot(Figure):
10 10
11 11 isConfig = None
12 12 __nsubplots = None
13 13
14 14 WIDTHPROF = None
15 15 HEIGHTPROF = None
16 16 PREFIX = 'SpcParam'
17 17
18 18 def __init__(self, **kwargs):
19 19 Figure.__init__(self, **kwargs)
20 20 self.isConfig = False
21 21 self.__nsubplots = 1
22 22
23 23 self.WIDTH = 250
24 24 self.HEIGHT = 250
25 25 self.WIDTHPROF = 120
26 26 self.HEIGHTPROF = 0
27 27 self.counter_imagwr = 0
28 28
29 29 self.PLOT_CODE = SPEC_CODE
30 30
31 31 self.FTP_WEI = None
32 32 self.EXP_CODE = None
33 33 self.SUB_EXP_CODE = None
34 34 self.PLOT_POS = None
35 35
36 36 self.__xfilter_ena = False
37 37 self.__yfilter_ena = False
38 38
39 39 def getSubplots(self):
40 40
41 41 ncol = int(numpy.sqrt(self.nplots)+0.9)
42 42 nrow = int(self.nplots*1./ncol + 0.9)
43 43
44 44 return nrow, ncol
45 45
46 46 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
47 47
48 48 self.__showprofile = showprofile
49 49 self.nplots = nplots
50 50
51 51 ncolspan = 1
52 52 colspan = 1
53 53 if showprofile:
54 54 ncolspan = 3
55 55 colspan = 2
56 56 self.__nsubplots = 2
57 57
58 58 self.createFigure(id = id,
59 59 wintitle = wintitle,
60 60 widthplot = self.WIDTH + self.WIDTHPROF,
61 61 heightplot = self.HEIGHT + self.HEIGHTPROF,
62 62 show=show)
63 63
64 64 nrow, ncol = self.getSubplots()
65 65
66 66 counter = 0
67 67 for y in range(nrow):
68 68 for x in range(ncol):
69 69
70 70 if counter >= self.nplots:
71 71 break
72 72
73 73 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
74 74
75 75 if showprofile:
76 76 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
77 77
78 78 counter += 1
79 79
80 80 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
81 81 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
82 82 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
83 83 server=None, folder=None, username=None, password=None,
84 84 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
85 85 xaxis="frequency", colormap='jet', normFactor=None , Selector = 0):
86 86
87 87 """
88 88
89 89 Input:
90 90 dataOut :
91 91 id :
92 92 wintitle :
93 93 channelList :
94 94 showProfile :
95 95 xmin : None,
96 96 xmax : None,
97 97 ymin : None,
98 98 ymax : None,
99 99 zmin : None,
100 100 zmax : None
101 101 """
102 102 if realtime:
103 103 if not(isRealtime(utcdatatime = dataOut.utctime)):
104 104 print 'Skipping this plot function'
105 105 return
106 106
107 107 if channelList == None:
108 108 channelIndexList = dataOut.channelIndexList
109 109 else:
110 110 channelIndexList = []
111 111 for channel in channelList:
112 112 if channel not in dataOut.channelList:
113 113 raise ValueError, "Channel %d is not in dataOut.channelList" %channel
114 114 channelIndexList.append(dataOut.channelList.index(channel))
115 115
116 116 # if normFactor is None:
117 117 # factor = dataOut.normFactor
118 118 # else:
119 119 # factor = normFactor
120 120 if xaxis == "frequency":
121 121 x = dataOut.spcparam_range[0]
122 122 xlabel = "Frequency (kHz)"
123 123
124 124 elif xaxis == "time":
125 125 x = dataOut.spcparam_range[1]
126 126 xlabel = "Time (ms)"
127 127
128 128 else:
129 129 x = dataOut.spcparam_range[2]
130 130 xlabel = "Velocity (m/s)"
131 print "Vmax=",x[-1]
131 132
132 133 ylabel = "Range (Km)"
133 134
134 135 y = dataOut.getHeiRange()
135 136
136 z = dataOut.SPCparam[Selector] #GauSelector] #dataOut.data_spc/factor
137 z = dataOut.SPCparam[Selector] /1966080.0#/ dataOut.normFactor#GauSelector] #dataOut.data_spc/factor
137 138 #print 'GausSPC', z[0,32,10:40]
138 139 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
139 140 zdB = 10*numpy.log10(z)
140 141
141 142 avg = numpy.average(z, axis=1)
142 143 avgdB = 10*numpy.log10(avg)
143 144
144 145 noise = dataOut.spc_noise
145 146 noisedB = 10*numpy.log10(noise)
146 147
147 148 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
148 149 title = wintitle + " Spectra"
149 150 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
150 151 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
151 152
152 153 if not self.isConfig:
153 154
154 155 nplots = len(channelIndexList)
155 156
156 157 self.setup(id=id,
157 158 nplots=nplots,
158 159 wintitle=wintitle,
159 160 showprofile=showprofile,
160 161 show=show)
161 162
162 163 if xmin == None: xmin = numpy.nanmin(x)
163 164 if xmax == None: xmax = numpy.nanmax(x)
164 165 if ymin == None: ymin = numpy.nanmin(y)
165 166 if ymax == None: ymax = numpy.nanmax(y)
166 167 if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
167 168 if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
168 169
169 170 self.FTP_WEI = ftp_wei
170 171 self.EXP_CODE = exp_code
171 172 self.SUB_EXP_CODE = sub_exp_code
172 173 self.PLOT_POS = plot_pos
173 174
174 175 self.isConfig = True
175 176
176 177 self.setWinTitle(title)
177 178
178 179 for i in range(self.nplots):
179 180 index = channelIndexList[i]
180 181 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
181 182 title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[index], noisedB[index], str_datetime)
182 183 if len(dataOut.beam.codeList) != 0:
183 184 title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[index], noisedB[index], dataOut.beam.azimuthList[index], dataOut.beam.zenithList[index], str_datetime)
184 185
185 186 axes = self.axesList[i*self.__nsubplots]
186 187 axes.pcolor(x, y, zdB[index,:,:],
187 188 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
188 189 xlabel=xlabel, ylabel=ylabel, title=title, colormap=colormap,
189 190 ticksize=9, cblabel='')
190 191
191 192 if self.__showprofile:
192 193 axes = self.axesList[i*self.__nsubplots +1]
193 194 axes.pline(avgdB[index,:], y,
194 195 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
195 196 xlabel='dB', ylabel='', title='',
196 197 ytick_visible=False,
197 198 grid='x')
198 199
199 200 noiseline = numpy.repeat(noisedB[index], len(y))
200 201 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
201 202
202 203 self.draw()
203 204
204 205 if figfile == None:
205 206 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
206 207 name = str_datetime
207 208 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
208 209 name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
209 210 figfile = self.getFilename(name)
210 211
211 212 self.save(figpath=figpath,
212 213 figfile=figfile,
213 214 save=save,
214 215 ftp=ftp,
215 216 wr_period=wr_period,
216 217 thisDatetime=thisDatetime)
217 218
218 219
219 220
220 221 class MomentsPlot(Figure):
221 222
222 223 isConfig = None
223 224 __nsubplots = None
224 225
225 226 WIDTHPROF = None
226 227 HEIGHTPROF = None
227 228 PREFIX = 'prm'
228 229
229 230 def __init__(self, **kwargs):
230 231 Figure.__init__(self, **kwargs)
231 232 self.isConfig = False
232 233 self.__nsubplots = 1
233 234
234 235 self.WIDTH = 280
235 236 self.HEIGHT = 250
236 237 self.WIDTHPROF = 120
237 238 self.HEIGHTPROF = 0
238 239 self.counter_imagwr = 0
239 240
240 241 self.PLOT_CODE = MOMENTS_CODE
241 242
242 243 self.FTP_WEI = None
243 244 self.EXP_CODE = None
244 245 self.SUB_EXP_CODE = None
245 246 self.PLOT_POS = None
246 247
247 248 def getSubplots(self):
248 249
249 250 ncol = int(numpy.sqrt(self.nplots)+0.9)
250 251 nrow = int(self.nplots*1./ncol + 0.9)
251 252
252 253 return nrow, ncol
253 254
254 255 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
255 256
256 257 self.__showprofile = showprofile
257 258 self.nplots = nplots
258 259
259 260 ncolspan = 1
260 261 colspan = 1
261 262 if showprofile:
262 263 ncolspan = 3
263 264 colspan = 2
264 265 self.__nsubplots = 2
265 266
266 267 self.createFigure(id = id,
267 268 wintitle = wintitle,
268 269 widthplot = self.WIDTH + self.WIDTHPROF,
269 270 heightplot = self.HEIGHT + self.HEIGHTPROF,
270 271 show=show)
271 272
272 273 nrow, ncol = self.getSubplots()
273 274
274 275 counter = 0
275 276 for y in range(nrow):
276 277 for x in range(ncol):
277 278
278 279 if counter >= self.nplots:
279 280 break
280 281
281 282 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
282 283
283 284 if showprofile:
284 285 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
285 286
286 287 counter += 1
287 288
288 289 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
289 290 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
290 291 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
291 292 server=None, folder=None, username=None, password=None,
292 293 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
293 294
294 295 """
295 296
296 297 Input:
297 298 dataOut :
298 299 id :
299 300 wintitle :
300 301 channelList :
301 302 showProfile :
302 303 xmin : None,
303 304 xmax : None,
304 305 ymin : None,
305 306 ymax : None,
306 307 zmin : None,
307 308 zmax : None
308 309 """
309 310
310 311 if dataOut.flagNoData:
311 312 return None
312 313
313 314 if realtime:
314 315 if not(isRealtime(utcdatatime = dataOut.utctime)):
315 316 print 'Skipping this plot function'
316 317 return
317 318
318 319 if channelList == None:
319 320 channelIndexList = dataOut.channelIndexList
320 321 else:
321 322 channelIndexList = []
322 323 for channel in channelList:
323 324 if channel not in dataOut.channelList:
324 325 raise ValueError, "Channel %d is not in dataOut.channelList"
325 326 channelIndexList.append(dataOut.channelList.index(channel))
326 327
327 328 factor = dataOut.normFactor
328 329 x = dataOut.abscissaList
329 330 y = dataOut.heightList
330 331
331 332 z = dataOut.data_pre[channelIndexList,:,:]/factor
332 333 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
333 334 avg = numpy.average(z, axis=1)
334 335 noise = dataOut.noise/factor
335 336
336 337 zdB = 10*numpy.log10(z)
337 338 avgdB = 10*numpy.log10(avg)
338 339 noisedB = 10*numpy.log10(noise)
339 340
340 341 #thisDatetime = dataOut.datatime
341 342 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
342 343 title = wintitle + " Parameters"
343 344 xlabel = "Velocity (m/s)"
344 345 ylabel = "Range (Km)"
345 346
346 347 update_figfile = False
347 348
348 349 if not self.isConfig:
349 350
350 351 nplots = len(channelIndexList)
351 352
352 353 self.setup(id=id,
353 354 nplots=nplots,
354 355 wintitle=wintitle,
355 356 showprofile=showprofile,
356 357 show=show)
357 358
358 359 if xmin == None: xmin = numpy.nanmin(x)
359 360 if xmax == None: xmax = numpy.nanmax(x)
360 361 if ymin == None: ymin = numpy.nanmin(y)
361 362 if ymax == None: ymax = numpy.nanmax(y)
362 363 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
363 364 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
364 365
365 366 self.FTP_WEI = ftp_wei
366 367 self.EXP_CODE = exp_code
367 368 self.SUB_EXP_CODE = sub_exp_code
368 369 self.PLOT_POS = plot_pos
369 370
370 371 self.isConfig = True
371 372 update_figfile = True
372 373
373 374 self.setWinTitle(title)
374 375
375 376 for i in range(self.nplots):
376 377 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
377 378 title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i], noisedB[i], str_datetime)
378 379 axes = self.axesList[i*self.__nsubplots]
379 380 axes.pcolor(x, y, zdB[i,:,:],
380 381 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
381 382 xlabel=xlabel, ylabel=ylabel, title=title,
382 383 ticksize=9, cblabel='')
383 384 #Mean Line
384 385 mean = dataOut.data_param[i, 1, :]
385 386 axes.addpline(mean, y, idline=0, color="black", linestyle="solid", lw=1)
386 387
387 388 if self.__showprofile:
388 389 axes = self.axesList[i*self.__nsubplots +1]
389 390 axes.pline(avgdB[i], y,
390 391 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
391 392 xlabel='dB', ylabel='', title='',
392 393 ytick_visible=False,
393 394 grid='x')
394 395
395 396 noiseline = numpy.repeat(noisedB[i], len(y))
396 397 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
397 398
398 399 self.draw()
399 400
400 401 self.save(figpath=figpath,
401 402 figfile=figfile,
402 403 save=save,
403 404 ftp=ftp,
404 405 wr_period=wr_period,
405 406 thisDatetime=thisDatetime)
406 407
407 408
408 409
409 410 class SkyMapPlot(Figure):
410 411
411 412 __isConfig = None
412 413 __nsubplots = None
413 414
414 415 WIDTHPROF = None
415 416 HEIGHTPROF = None
416 417 PREFIX = 'mmap'
417 418
418 419 def __init__(self, **kwargs):
419 420 Figure.__init__(self, **kwargs)
420 421 self.isConfig = False
421 422 self.__nsubplots = 1
422 423
423 424 # self.WIDTH = 280
424 425 # self.HEIGHT = 250
425 426 self.WIDTH = 600
426 427 self.HEIGHT = 600
427 428 self.WIDTHPROF = 120
428 429 self.HEIGHTPROF = 0
429 430 self.counter_imagwr = 0
430 431
431 432 self.PLOT_CODE = MSKYMAP_CODE
432 433
433 434 self.FTP_WEI = None
434 435 self.EXP_CODE = None
435 436 self.SUB_EXP_CODE = None
436 437 self.PLOT_POS = None
437 438
438 439 def getSubplots(self):
439 440
440 441 ncol = int(numpy.sqrt(self.nplots)+0.9)
441 442 nrow = int(self.nplots*1./ncol + 0.9)
442 443
443 444 return nrow, ncol
444 445
445 446 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
446 447
447 448 self.__showprofile = showprofile
448 449 self.nplots = nplots
449 450
450 451 ncolspan = 1
451 452 colspan = 1
452 453
453 454 self.createFigure(id = id,
454 455 wintitle = wintitle,
455 456 widthplot = self.WIDTH, #+ self.WIDTHPROF,
456 457 heightplot = self.HEIGHT,# + self.HEIGHTPROF,
457 458 show=show)
458 459
459 460 nrow, ncol = 1,1
460 461 counter = 0
461 462 x = 0
462 463 y = 0
463 464 self.addAxes(1, 1, 0, 0, 1, 1, True)
464 465
465 466 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
466 467 tmin=0, tmax=24, timerange=None,
467 468 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
468 469 server=None, folder=None, username=None, password=None,
469 470 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
470 471
471 472 """
472 473
473 474 Input:
474 475 dataOut :
475 476 id :
476 477 wintitle :
477 478 channelList :
478 479 showProfile :
479 480 xmin : None,
480 481 xmax : None,
481 482 ymin : None,
482 483 ymax : None,
483 484 zmin : None,
484 485 zmax : None
485 486 """
486 487
487 488 arrayParameters = dataOut.data_param
488 489 error = arrayParameters[:,-1]
489 490 indValid = numpy.where(error == 0)[0]
490 491 finalMeteor = arrayParameters[indValid,:]
491 492 finalAzimuth = finalMeteor[:,3]
492 493 finalZenith = finalMeteor[:,4]
493 494
494 495 x = finalAzimuth*numpy.pi/180
495 496 y = finalZenith
496 497 x1 = [dataOut.ltctime, dataOut.ltctime]
497 498
498 499 #thisDatetime = dataOut.datatime
499 500 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
500 501 title = wintitle + " Parameters"
501 502 xlabel = "Zonal Zenith Angle (deg) "
502 503 ylabel = "Meridional Zenith Angle (deg)"
503 504 update_figfile = False
504 505
505 506 if not self.isConfig:
506 507
507 508 nplots = 1
508 509
509 510 self.setup(id=id,
510 511 nplots=nplots,
511 512 wintitle=wintitle,
512 513 showprofile=showprofile,
513 514 show=show)
514 515
515 516 if self.xmin is None and self.xmax is None:
516 517 self.xmin, self.xmax = self.getTimeLim(x1, tmin, tmax, timerange)
517 518
518 519 if timerange != None:
519 520 self.timerange = timerange
520 521 else:
521 522 self.timerange = self.xmax - self.xmin
522 523
523 524 self.FTP_WEI = ftp_wei
524 525 self.EXP_CODE = exp_code
525 526 self.SUB_EXP_CODE = sub_exp_code
526 527 self.PLOT_POS = plot_pos
527 528 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
528 529 self.firstdate = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
529 530 self.isConfig = True
530 531 update_figfile = True
531 532
532 533 self.setWinTitle(title)
533 534
534 535 i = 0
535 536 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
536 537
537 538 axes = self.axesList[i*self.__nsubplots]
538 539 nevents = axes.x_buffer.shape[0] + x.shape[0]
539 540 title = "Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n" %(self.firstdate,str_datetime,nevents)
540 541 axes.polar(x, y,
541 542 title=title, xlabel=xlabel, ylabel=ylabel,
542 543 ticksize=9, cblabel='')
543 544
544 545 self.draw()
545 546
546 547 self.save(figpath=figpath,
547 548 figfile=figfile,
548 549 save=save,
549 550 ftp=ftp,
550 551 wr_period=wr_period,
551 552 thisDatetime=thisDatetime,
552 553 update_figfile=update_figfile)
553 554
554 555 if dataOut.ltctime >= self.xmax:
555 556 self.isConfigmagwr = wr_period
556 557 self.isConfig = False
557 558 update_figfile = True
558 559 axes.__firsttime = True
559 560 self.xmin += self.timerange
560 561 self.xmax += self.timerange
561 562
562 563
563 564
564 565
565 566 class WindProfilerPlot(Figure):
566 567
567 568 __isConfig = None
568 569 __nsubplots = None
569 570
570 571 WIDTHPROF = None
571 572 HEIGHTPROF = None
572 573 PREFIX = 'wind'
573 574
574 575 def __init__(self, **kwargs):
575 576 Figure.__init__(self, **kwargs)
576 577 self.timerange = None
577 578 self.isConfig = False
578 579 self.__nsubplots = 1
579 580
580 581 self.WIDTH = 800
581 582 self.HEIGHT = 300
582 583 self.WIDTHPROF = 120
583 584 self.HEIGHTPROF = 0
584 585 self.counter_imagwr = 0
585 586
586 587 self.PLOT_CODE = WIND_CODE
587 588
588 589 self.FTP_WEI = None
589 590 self.EXP_CODE = None
590 591 self.SUB_EXP_CODE = None
591 592 self.PLOT_POS = None
592 593 self.tmin = None
593 594 self.tmax = None
594 595
595 596 self.xmin = None
596 597 self.xmax = None
597 598
598 599 self.figfile = None
599 600
600 601 def getSubplots(self):
601 602
602 603 ncol = 1
603 604 nrow = self.nplots
604 605
605 606 return nrow, ncol
606 607
607 608 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
608 609
609 610 self.__showprofile = showprofile
610 611 self.nplots = nplots
611 612
612 613 ncolspan = 1
613 614 colspan = 1
614 615
615 616 self.createFigure(id = id,
616 617 wintitle = wintitle,
617 618 widthplot = self.WIDTH + self.WIDTHPROF,
618 619 heightplot = self.HEIGHT + self.HEIGHTPROF,
619 620 show=show)
620 621
621 622 nrow, ncol = self.getSubplots()
622 623
623 624 counter = 0
624 625 for y in range(nrow):
625 626 if counter >= self.nplots:
626 627 break
627 628
628 629 self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
629 630 counter += 1
630 631
631 632 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='False',
632 633 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
633 634 zmax_ver = None, zmin_ver = None, SNRmin = None, SNRmax = None,
634 635 timerange=None, SNRthresh = None,
635 636 save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
636 637 server=None, folder=None, username=None, password=None,
637 638 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
638 639 """
639 640
640 641 Input:
641 642 dataOut :
642 643 id :
643 644 wintitle :
644 645 channelList :
645 646 showProfile :
646 647 xmin : None,
647 648 xmax : None,
648 649 ymin : None,
649 650 ymax : None,
650 651 zmin : None,
651 652 zmax : None
652 653 """
653 654
654 655 # if timerange is not None:
655 656 # self.timerange = timerange
656 657 #
657 658 # tmin = None
658 659 # tmax = None
659 660
660 661 x = dataOut.getTimeRange1(dataOut.paramInterval)
661 662 y = dataOut.heightList
662 663 z = dataOut.data_output.copy()
663 664 nplots = z.shape[0] #Number of wind dimensions estimated
664 665 nplotsw = nplots
665 666
666 667
667 668 #If there is a SNR function defined
668 669 if dataOut.data_SNR is not None:
669 670 nplots += 1
670 671 SNR = dataOut.data_SNR[0]
671 672 SNRavg = SNR#numpy.average(SNR, axis=0)
672 673
673 674 SNRdB = 10*numpy.log10(SNR)
674 675 SNRavgdB = 10*numpy.log10(SNRavg)
675 676
676 677 if SNRthresh == None:
677 678 SNRthresh = -5.0
678 679 ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
679 680
680 681 for i in range(nplotsw):
681 682 z[i,ind] = numpy.nan
682 683
683 684 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
684 685 #thisDatetime = datetime.datetime.now()
685 686 title = wintitle + "Wind"
686 687 xlabel = ""
687 688 ylabel = "Height (km)"
688 689 update_figfile = False
689 690
690 691 if not self.isConfig:
691 692
692 693 self.setup(id=id,
693 694 nplots=nplots,
694 695 wintitle=wintitle,
695 696 showprofile=showprofile,
696 697 show=show)
697 698
698 699 if timerange is not None:
699 700 self.timerange = timerange
700 701
701 702 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
702 703
703 704 if ymin == None: ymin = numpy.nanmin(y)
704 705 if ymax == None: ymax = numpy.nanmax(y)
705 706
706 707 if zmax == None: zmax = numpy.nanmax(abs(z[range(2),:]))
707 708 #if numpy.isnan(zmax): zmax = 50
708 709 if zmin == None: zmin = -zmax
709 710
710 711 if nplotsw == 3:
711 712 if zmax_ver == None: zmax_ver = numpy.nanmax(abs(z[2,:]))
712 713 if zmin_ver == None: zmin_ver = -zmax_ver
713 714
714 715 if dataOut.data_SNR is not None:
715 716 if SNRmin == None: SNRmin = numpy.nanmin(SNRavgdB)
716 717 if SNRmax == None: SNRmax = numpy.nanmax(SNRavgdB)
717 718
718 719
719 720 self.FTP_WEI = ftp_wei
720 721 self.EXP_CODE = exp_code
721 722 self.SUB_EXP_CODE = sub_exp_code
722 723 self.PLOT_POS = plot_pos
723 724
724 725 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
725 726 self.isConfig = True
726 727 self.figfile = figfile
727 728 update_figfile = True
728 729
729 730 self.setWinTitle(title)
730 731
731 732 if ((self.xmax - x[1]) < (x[1]-x[0])):
732 733 x[1] = self.xmax
733 734
734 735 strWind = ['Zonal', 'Meridional', 'Vertical']
735 736 strCb = ['Velocity (m/s)','Velocity (m/s)','Velocity (cm/s)']
736 737 zmaxVector = [zmax, zmax, zmax_ver]
737 738 zminVector = [zmin, zmin, zmin_ver]
738 739 windFactor = [1,1,100]
739 740
740 741 for i in range(nplotsw):
741 742
742 743 title = "%s Wind: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
743 744 axes = self.axesList[i*self.__nsubplots]
744 745
745 746 z1 = z[i,:].reshape((1,-1))*windFactor[i]
746 747
747 748 print 'x', x
748 749 print datetime.datetime.utcfromtimestamp(x[0])
749 750 print datetime.datetime.utcfromtimestamp(x[1])
750 751
751 752 #z1=numpy.ma.masked_where(z1==0.,z1)
752 753
753 754 axes.pcolorbuffer(x, y, z1,
754 755 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
755 756 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
756 757 ticksize=9, cblabel=strCb[i], cbsize="1%", colormap="seismic" )
757 758
758 759 if dataOut.data_SNR is not None:
759 760 i += 1
760 761 title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
761 762 axes = self.axesList[i*self.__nsubplots]
762 763 SNRavgdB = SNRavgdB.reshape((1,-1))
763 764 axes.pcolorbuffer(x, y, SNRavgdB,
764 765 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
765 766 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
766 767 ticksize=9, cblabel='', cbsize="1%", colormap="jet")
767 768
768 769 self.draw()
769 770
770 771 self.save(figpath=figpath,
771 772 figfile=figfile,
772 773 save=save,
773 774 ftp=ftp,
774 775 wr_period=wr_period,
775 776 thisDatetime=thisDatetime,
776 777 update_figfile=update_figfile)
777 778
778 779 if dataOut.ltctime + dataOut.paramInterval >= self.xmax:
779 780 self.counter_imagwr = wr_period
780 781 self.isConfig = False
781 782 update_figfile = True
782 783
783 784
784 785 class ParametersPlot(Figure):
785 786
786 787 __isConfig = None
787 788 __nsubplots = None
788 789
789 790 WIDTHPROF = None
790 791 HEIGHTPROF = None
791 792 PREFIX = 'param'
792 793
793 794 nplots = None
794 795 nchan = None
795 796
796 797 def __init__(self, **kwargs):
797 798 Figure.__init__(self, **kwargs)
798 799 self.timerange = None
799 800 self.isConfig = False
800 801 self.__nsubplots = 1
801 802
802 803 self.WIDTH = 800
803 804 self.HEIGHT = 180
804 805 self.WIDTHPROF = 120
805 806 self.HEIGHTPROF = 0
806 807 self.counter_imagwr = 0
807 808
808 809 self.PLOT_CODE = RTI_CODE
809 810
810 811 self.FTP_WEI = None
811 812 self.EXP_CODE = None
812 813 self.SUB_EXP_CODE = None
813 814 self.PLOT_POS = None
814 815 self.tmin = None
815 816 self.tmax = None
816 817
817 818 self.xmin = None
818 819 self.xmax = None
819 820
820 821 self.figfile = None
821 822
822 823 def getSubplots(self):
823 824
824 825 ncol = 1
825 826 nrow = self.nplots
826 827
827 828 return nrow, ncol
828 829
829 830 def setup(self, id, nplots, wintitle, show=True):
830 831
831 832 self.nplots = nplots
832 833
833 834 ncolspan = 1
834 835 colspan = 1
835 836
836 837 self.createFigure(id = id,
837 838 wintitle = wintitle,
838 839 widthplot = self.WIDTH + self.WIDTHPROF,
839 840 heightplot = self.HEIGHT + self.HEIGHTPROF,
840 841 show=show)
841 842
842 843 nrow, ncol = self.getSubplots()
843 844
844 845 counter = 0
845 846 for y in range(nrow):
846 847 for x in range(ncol):
847 848
848 849 if counter >= self.nplots:
849 850 break
850 851
851 852 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
852 853
853 854 counter += 1
854 855
855 856 def run(self, dataOut, id, wintitle="", channelList=None, paramIndex = 0, colormap="jet",
856 857 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, timerange=None,
857 858 showSNR=False, SNRthresh = -numpy.inf, SNRmin=None, SNRmax=None,
858 859 save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
859 860 server=None, folder=None, username=None, password=None,
860 861 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, HEIGHT=None):
861 862 """
862 863
863 864 Input:
864 865 dataOut :
865 866 id :
866 867 wintitle :
867 868 channelList :
868 869 showProfile :
869 870 xmin : None,
870 871 xmax : None,
871 872 ymin : None,
872 873 ymax : None,
873 874 zmin : None,
874 875 zmax : None
875 876 """
876 877
877 878 if HEIGHT is not None:
878 879 self.HEIGHT = HEIGHT
879 880
880 881
881 882 if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
882 883 return
883 884
884 885 if channelList == None:
885 886 channelIndexList = range(dataOut.data_param.shape[0])
886 887 else:
887 888 channelIndexList = []
888 889 for channel in channelList:
889 890 if channel not in dataOut.channelList:
890 891 raise ValueError, "Channel %d is not in dataOut.channelList"
891 892 channelIndexList.append(dataOut.channelList.index(channel))
892 893
893 894 x = dataOut.getTimeRange1(dataOut.paramInterval)
894 895 y = dataOut.getHeiRange()
895 896
896 897 if dataOut.data_param.ndim == 3:
897 898 z = dataOut.data_param[channelIndexList,paramIndex,:]
898 899 else:
899 900 z = dataOut.data_param[channelIndexList,:]
900 901
901 902 if showSNR:
902 903 #SNR data
903 904 SNRarray = dataOut.data_SNR[channelIndexList,:]
904 905 SNRdB = 10*numpy.log10(SNRarray)
905 906 ind = numpy.where(SNRdB < SNRthresh)
906 907 z[ind] = numpy.nan
907 908
908 909 thisDatetime = dataOut.datatime
909 910 # thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
910 911 title = wintitle + " Parameters Plot" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
911 912 xlabel = ""
912 913 ylabel = "Range (Km)"
913 914
914 915 update_figfile = False
915 916
916 917 if not self.isConfig:
917 918
918 919 nchan = len(channelIndexList)
919 920 self.nchan = nchan
920 921 self.plotFact = 1
921 922 nplots = nchan
922 923
923 924 if showSNR:
924 925 nplots = nchan*2
925 926 self.plotFact = 2
926 927 if SNRmin == None: SNRmin = numpy.nanmin(SNRdB)
927 928 if SNRmax == None: SNRmax = numpy.nanmax(SNRdB)
928 929
929 930 self.setup(id=id,
930 931 nplots=nplots,
931 932 wintitle=wintitle,
932 933 show=show)
933 934
934 935 if timerange != None:
935 936 self.timerange = timerange
936 937
937 938 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
938 939
939 940 if ymin == None: ymin = numpy.nanmin(y)
940 941 if ymax == None: ymax = numpy.nanmax(y)
941 942 if zmin == None: zmin = numpy.nanmin(z)
942 943 if zmax == None: zmax = numpy.nanmax(z)
943 944
944 945 self.FTP_WEI = ftp_wei
945 946 self.EXP_CODE = exp_code
946 947 self.SUB_EXP_CODE = sub_exp_code
947 948 self.PLOT_POS = plot_pos
948 949
949 950 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
950 951 self.isConfig = True
951 952 self.figfile = figfile
952 953 update_figfile = True
953 954
954 955 self.setWinTitle(title)
955 956
956 957 for i in range(self.nchan):
957 958 index = channelIndexList[i]
958 959 title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
959 960 axes = self.axesList[i*self.plotFact]
960 961 z1 = z[i,:].reshape((1,-1))
961 962 axes.pcolorbuffer(x, y, z1,
962 963 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
963 964 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
964 965 ticksize=9, cblabel='', cbsize="1%",colormap=colormap)
965 966
966 967 if showSNR:
967 968 title = "Channel %d SNR: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
968 969 axes = self.axesList[i*self.plotFact + 1]
969 970 SNRdB1 = SNRdB[i,:].reshape((1,-1))
970 971 axes.pcolorbuffer(x, y, SNRdB1,
971 972 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
972 973 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
973 974 ticksize=9, cblabel='', cbsize="1%",colormap='jet')
974 975
975 976
976 977 self.draw()
977 978
978 979 if dataOut.ltctime >= self.xmax:
979 980 self.counter_imagwr = wr_period
980 981 self.isConfig = False
981 982 update_figfile = True
982 983
983 984 self.save(figpath=figpath,
984 985 figfile=figfile,
985 986 save=save,
986 987 ftp=ftp,
987 988 wr_period=wr_period,
988 989 thisDatetime=thisDatetime,
989 990 update_figfile=update_figfile)
990 991
991 992
992 993
993 994 class Parameters1Plot(Figure):
994 995
995 996 __isConfig = None
996 997 __nsubplots = None
997 998
998 999 WIDTHPROF = None
999 1000 HEIGHTPROF = None
1000 1001 PREFIX = 'prm'
1001 1002
1002 1003 def __init__(self, **kwargs):
1003 1004 Figure.__init__(self, **kwargs)
1004 1005 self.timerange = 2*60*60
1005 1006 self.isConfig = False
1006 1007 self.__nsubplots = 1
1007 1008
1008 1009 self.WIDTH = 800
1009 1010 self.HEIGHT = 180
1010 1011 self.WIDTHPROF = 120
1011 1012 self.HEIGHTPROF = 0
1012 1013 self.counter_imagwr = 0
1013 1014
1014 1015 self.PLOT_CODE = PARMS_CODE
1015 1016
1016 1017 self.FTP_WEI = None
1017 1018 self.EXP_CODE = None
1018 1019 self.SUB_EXP_CODE = None
1019 1020 self.PLOT_POS = None
1020 1021 self.tmin = None
1021 1022 self.tmax = None
1022 1023
1023 1024 self.xmin = None
1024 1025 self.xmax = None
1025 1026
1026 1027 self.figfile = None
1027 1028
1028 1029 def getSubplots(self):
1029 1030
1030 1031 ncol = 1
1031 1032 nrow = self.nplots
1032 1033
1033 1034 return nrow, ncol
1034 1035
1035 1036 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1036 1037
1037 1038 self.__showprofile = showprofile
1038 1039 self.nplots = nplots
1039 1040
1040 1041 ncolspan = 1
1041 1042 colspan = 1
1042 1043
1043 1044 self.createFigure(id = id,
1044 1045 wintitle = wintitle,
1045 1046 widthplot = self.WIDTH + self.WIDTHPROF,
1046 1047 heightplot = self.HEIGHT + self.HEIGHTPROF,
1047 1048 show=show)
1048 1049
1049 1050 nrow, ncol = self.getSubplots()
1050 1051
1051 1052 counter = 0
1052 1053 for y in range(nrow):
1053 1054 for x in range(ncol):
1054 1055
1055 1056 if counter >= self.nplots:
1056 1057 break
1057 1058
1058 1059 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
1059 1060
1060 1061 if showprofile:
1061 1062 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
1062 1063
1063 1064 counter += 1
1064 1065
1065 1066 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
1066 1067 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,timerange=None,
1067 1068 parameterIndex = None, onlyPositive = False,
1068 1069 SNRthresh = -numpy.inf, SNR = True, SNRmin = None, SNRmax = None, onlySNR = False,
1069 1070 DOP = True,
1070 1071 zlabel = "", parameterName = "", parameterObject = "data_param",
1071 1072 save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
1072 1073 server=None, folder=None, username=None, password=None,
1073 1074 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1074 1075 #print inspect.getargspec(self.run).args
1075 1076 """
1076 1077
1077 1078 Input:
1078 1079 dataOut :
1079 1080 id :
1080 1081 wintitle :
1081 1082 channelList :
1082 1083 showProfile :
1083 1084 xmin : None,
1084 1085 xmax : None,
1085 1086 ymin : None,
1086 1087 ymax : None,
1087 1088 zmin : None,
1088 1089 zmax : None
1089 1090 """
1090 1091
1091 1092 data_param = getattr(dataOut, parameterObject)
1092 1093
1093 1094 if channelList == None:
1094 1095 channelIndexList = numpy.arange(data_param.shape[0])
1095 1096 else:
1096 1097 channelIndexList = numpy.array(channelList)
1097 1098
1098 1099 nchan = len(channelIndexList) #Number of channels being plotted
1099 1100
1100 1101 if nchan < 1:
1101 1102 return
1102 1103
1103 1104 nGraphsByChannel = 0
1104 1105
1105 1106 if SNR:
1106 1107 nGraphsByChannel += 1
1107 1108 if DOP:
1108 1109 nGraphsByChannel += 1
1109 1110
1110 1111 if nGraphsByChannel < 1:
1111 1112 return
1112 1113
1113 1114 nplots = nGraphsByChannel*nchan
1114 1115
1115 1116 if timerange is not None:
1116 1117 self.timerange = timerange
1117 1118
1118 1119 #tmin = None
1119 1120 #tmax = None
1120 1121 if parameterIndex == None:
1121 1122 parameterIndex = 1
1122 1123
1123 1124 x = dataOut.getTimeRange1(dataOut.paramInterval)
1124 1125 y = dataOut.heightList
1125 1126 z = data_param[channelIndexList,parameterIndex,:].copy()
1126 1127
1127 1128 zRange = dataOut.abscissaList
1128 1129 # nChannels = z.shape[0] #Number of wind dimensions estimated
1129 1130 # thisDatetime = dataOut.datatime
1130 1131
1131 1132 if dataOut.data_SNR is not None:
1132 1133 SNRarray = dataOut.data_SNR[channelIndexList,:]
1133 1134 SNRdB = 10*numpy.log10(SNRarray)
1134 1135 # SNRavgdB = 10*numpy.log10(SNRavg)
1135 1136 ind = numpy.where(SNRdB < 10**(SNRthresh/10))
1136 1137 z[ind] = numpy.nan
1137 1138
1138 1139 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
1139 1140 title = wintitle + " Parameters Plot" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
1140 1141 xlabel = ""
1141 1142 ylabel = "Range (Km)"
1142 1143
1143 1144 if (SNR and not onlySNR): nplots = 2*nplots
1144 1145
1145 1146 if onlyPositive:
1146 1147 colormap = "jet"
1147 1148 zmin = 0
1148 1149 else: colormap = "RdBu_r"
1149 1150
1150 1151 if not self.isConfig:
1151 1152
1152 1153 self.setup(id=id,
1153 1154 nplots=nplots,
1154 1155 wintitle=wintitle,
1155 1156 showprofile=showprofile,
1156 1157 show=show)
1157 1158
1158 1159 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
1159 1160
1160 1161 if ymin == None: ymin = numpy.nanmin(y)
1161 1162 if ymax == None: ymax = numpy.nanmax(y)
1162 1163 if zmin == None: zmin = numpy.nanmin(zRange)
1163 1164 if zmax == None: zmax = numpy.nanmax(zRange)
1164 1165
1165 1166 if SNR:
1166 1167 if SNRmin == None: SNRmin = numpy.nanmin(SNRdB)
1167 1168 if SNRmax == None: SNRmax = numpy.nanmax(SNRdB)
1168 1169
1169 1170 self.FTP_WEI = ftp_wei
1170 1171 self.EXP_CODE = exp_code
1171 1172 self.SUB_EXP_CODE = sub_exp_code
1172 1173 self.PLOT_POS = plot_pos
1173 1174
1174 1175 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1175 1176 self.isConfig = True
1176 1177 self.figfile = figfile
1177 1178
1178 1179 self.setWinTitle(title)
1179 1180
1180 1181 if ((self.xmax - x[1]) < (x[1]-x[0])):
1181 1182 x[1] = self.xmax
1182 1183
1183 1184 for i in range(nchan):
1184 1185
1185 1186 if (SNR and not onlySNR): j = 2*i
1186 1187 else: j = i
1187 1188
1188 1189 j = nGraphsByChannel*i
1189 1190
1190 1191 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
1191 1192 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
1192 1193
1193 1194 if not onlySNR:
1194 1195 axes = self.axesList[j*self.__nsubplots]
1195 1196 z1 = z[i,:].reshape((1,-1))
1196 1197 axes.pcolorbuffer(x, y, z1,
1197 1198 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
1198 1199 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap=colormap,
1199 1200 ticksize=9, cblabel=zlabel, cbsize="1%")
1200 1201
1201 1202 if DOP:
1202 1203 title = "%s Channel %d: %s" %(parameterName, channelIndexList[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1203 1204
1204 1205 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
1205 1206 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
1206 1207 axes = self.axesList[j]
1207 1208 z1 = z[i,:].reshape((1,-1))
1208 1209 axes.pcolorbuffer(x, y, z1,
1209 1210 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
1210 1211 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap=colormap,
1211 1212 ticksize=9, cblabel=zlabel, cbsize="1%")
1212 1213
1213 1214 if SNR:
1214 1215 title = "Channel %d Signal Noise Ratio (SNR): %s" %(channelIndexList[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1215 1216 axes = self.axesList[(j)*self.__nsubplots]
1216 1217 if not onlySNR:
1217 1218 axes = self.axesList[(j + 1)*self.__nsubplots]
1218 1219
1219 1220 axes = self.axesList[(j + nGraphsByChannel-1)]
1220 1221
1221 1222 z1 = SNRdB[i,:].reshape((1,-1))
1222 1223 axes.pcolorbuffer(x, y, z1,
1223 1224 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
1224 1225 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap="jet",
1225 1226 ticksize=9, cblabel=zlabel, cbsize="1%")
1226 1227
1227 1228
1228 1229
1229 1230 self.draw()
1230 1231
1231 1232 if x[1] >= self.axesList[0].xmax:
1232 1233 self.counter_imagwr = wr_period
1233 1234 self.isConfig = False
1234 1235 self.figfile = None
1235 1236
1236 1237 self.save(figpath=figpath,
1237 1238 figfile=figfile,
1238 1239 save=save,
1239 1240 ftp=ftp,
1240 1241 wr_period=wr_period,
1241 1242 thisDatetime=thisDatetime,
1242 1243 update_figfile=False)
1243 1244
1244 1245 class SpectralFittingPlot(Figure):
1245 1246
1246 1247 __isConfig = None
1247 1248 __nsubplots = None
1248 1249
1249 1250 WIDTHPROF = None
1250 1251 HEIGHTPROF = None
1251 1252 PREFIX = 'prm'
1252 1253
1253 1254
1254 1255 N = None
1255 1256 ippSeconds = None
1256 1257
1257 1258 def __init__(self, **kwargs):
1258 1259 Figure.__init__(self, **kwargs)
1259 1260 self.isConfig = False
1260 1261 self.__nsubplots = 1
1261 1262
1262 1263 self.PLOT_CODE = SPECFIT_CODE
1263 1264
1264 1265 self.WIDTH = 450
1265 1266 self.HEIGHT = 250
1266 1267 self.WIDTHPROF = 0
1267 1268 self.HEIGHTPROF = 0
1268 1269
1269 1270 def getSubplots(self):
1270 1271
1271 1272 ncol = int(numpy.sqrt(self.nplots)+0.9)
1272 1273 nrow = int(self.nplots*1./ncol + 0.9)
1273 1274
1274 1275 return nrow, ncol
1275 1276
1276 1277 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
1277 1278
1278 1279 showprofile = False
1279 1280 self.__showprofile = showprofile
1280 1281 self.nplots = nplots
1281 1282
1282 1283 ncolspan = 5
1283 1284 colspan = 4
1284 1285 if showprofile:
1285 1286 ncolspan = 5
1286 1287 colspan = 4
1287 1288 self.__nsubplots = 2
1288 1289
1289 1290 self.createFigure(id = id,
1290 1291 wintitle = wintitle,
1291 1292 widthplot = self.WIDTH + self.WIDTHPROF,
1292 1293 heightplot = self.HEIGHT + self.HEIGHTPROF,
1293 1294 show=show)
1294 1295
1295 1296 nrow, ncol = self.getSubplots()
1296 1297
1297 1298 counter = 0
1298 1299 for y in range(nrow):
1299 1300 for x in range(ncol):
1300 1301
1301 1302 if counter >= self.nplots:
1302 1303 break
1303 1304
1304 1305 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
1305 1306
1306 1307 if showprofile:
1307 1308 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
1308 1309
1309 1310 counter += 1
1310 1311
1311 1312 def run(self, dataOut, id, cutHeight=None, fit=False, wintitle="", channelList=None, showprofile=True,
1312 1313 xmin=None, xmax=None, ymin=None, ymax=None,
1313 1314 save=False, figpath='./', figfile=None, show=True):
1314 1315
1315 1316 """
1316 1317
1317 1318 Input:
1318 1319 dataOut :
1319 1320 id :
1320 1321 wintitle :
1321 1322 channelList :
1322 1323 showProfile :
1323 1324 xmin : None,
1324 1325 xmax : None,
1325 1326 zmin : None,
1326 1327 zmax : None
1327 1328 """
1328 1329
1329 1330 if cutHeight==None:
1330 1331 h=270
1331 1332 heightindex = numpy.abs(cutHeight - dataOut.heightList).argmin()
1332 1333 cutHeight = dataOut.heightList[heightindex]
1333 1334
1334 1335 factor = dataOut.normFactor
1335 1336 x = dataOut.abscissaList[:-1]
1336 1337 #y = dataOut.getHeiRange()
1337 1338
1338 1339 z = dataOut.data_pre[:,:,heightindex]/factor
1339 1340 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
1340 1341 avg = numpy.average(z, axis=1)
1341 1342 listChannels = z.shape[0]
1342 1343
1343 1344 #Reconstruct Function
1344 1345 if fit==True:
1345 1346 groupArray = dataOut.groupList
1346 1347 listChannels = groupArray.reshape((groupArray.size))
1347 1348 listChannels.sort()
1348 1349 spcFitLine = numpy.zeros(z.shape)
1349 1350 constants = dataOut.constants
1350 1351
1351 1352 nGroups = groupArray.shape[0]
1352 1353 nChannels = groupArray.shape[1]
1353 1354 nProfiles = z.shape[1]
1354 1355
1355 1356 for f in range(nGroups):
1356 1357 groupChann = groupArray[f,:]
1357 1358 p = dataOut.data_param[f,:,heightindex]
1358 1359 # p = numpy.array([ 89.343967,0.14036615,0.17086219,18.89835291,1.58388365,1.55099167])
1359 1360 fitLineAux = dataOut.library.modelFunction(p, constants)*nProfiles
1360 1361 fitLineAux = fitLineAux.reshape((nChannels,nProfiles))
1361 1362 spcFitLine[groupChann,:] = fitLineAux
1362 1363 # spcFitLine = spcFitLine/factor
1363 1364
1364 1365 z = z[listChannels,:]
1365 1366 spcFitLine = spcFitLine[listChannels,:]
1366 1367 spcFitLinedB = 10*numpy.log10(spcFitLine)
1367 1368
1368 1369 zdB = 10*numpy.log10(z)
1369 1370 #thisDatetime = dataOut.datatime
1370 1371 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
1371 1372 title = wintitle + " Doppler Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
1372 1373 xlabel = "Velocity (m/s)"
1373 1374 ylabel = "Spectrum"
1374 1375
1375 1376 if not self.isConfig:
1376 1377
1377 1378 nplots = listChannels.size
1378 1379
1379 1380 self.setup(id=id,
1380 1381 nplots=nplots,
1381 1382 wintitle=wintitle,
1382 1383 showprofile=showprofile,
1383 1384 show=show)
1384 1385
1385 1386 if xmin == None: xmin = numpy.nanmin(x)
1386 1387 if xmax == None: xmax = numpy.nanmax(x)
1387 1388 if ymin == None: ymin = numpy.nanmin(zdB)
1388 1389 if ymax == None: ymax = numpy.nanmax(zdB)+2
1389 1390
1390 1391 self.isConfig = True
1391 1392
1392 1393 self.setWinTitle(title)
1393 1394 for i in range(self.nplots):
1394 1395 # title = "Channel %d: %4.2fdB" %(dataOut.channelList[i]+1, noisedB[i])
1395 1396 title = "Height %4.1f km\nChannel %d:" %(cutHeight, listChannels[i])
1396 1397 axes = self.axesList[i*self.__nsubplots]
1397 1398 if fit == False:
1398 1399 axes.pline(x, zdB[i,:],
1399 1400 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
1400 1401 xlabel=xlabel, ylabel=ylabel, title=title
1401 1402 )
1402 1403 if fit == True:
1403 1404 fitline=spcFitLinedB[i,:]
1404 1405 y=numpy.vstack([zdB[i,:],fitline] )
1405 1406 legendlabels=['Data','Fitting']
1406 1407 axes.pmultilineyaxis(x, y,
1407 1408 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
1408 1409 xlabel=xlabel, ylabel=ylabel, title=title,
1409 1410 legendlabels=legendlabels, marker=None,
1410 1411 linestyle='solid', grid='both')
1411 1412
1412 1413 self.draw()
1413 1414
1414 1415 self.save(figpath=figpath,
1415 1416 figfile=figfile,
1416 1417 save=save,
1417 1418 ftp=ftp,
1418 1419 wr_period=wr_period,
1419 1420 thisDatetime=thisDatetime)
1420 1421
1421 1422
1422 1423 class EWDriftsPlot(Figure):
1423 1424
1424 1425 __isConfig = None
1425 1426 __nsubplots = None
1426 1427
1427 1428 WIDTHPROF = None
1428 1429 HEIGHTPROF = None
1429 1430 PREFIX = 'drift'
1430 1431
1431 1432 def __init__(self, **kwargs):
1432 1433 Figure.__init__(self, **kwargs)
1433 1434 self.timerange = 2*60*60
1434 1435 self.isConfig = False
1435 1436 self.__nsubplots = 1
1436 1437
1437 1438 self.WIDTH = 800
1438 1439 self.HEIGHT = 150
1439 1440 self.WIDTHPROF = 120
1440 1441 self.HEIGHTPROF = 0
1441 1442 self.counter_imagwr = 0
1442 1443
1443 1444 self.PLOT_CODE = EWDRIFT_CODE
1444 1445
1445 1446 self.FTP_WEI = None
1446 1447 self.EXP_CODE = None
1447 1448 self.SUB_EXP_CODE = None
1448 1449 self.PLOT_POS = None
1449 1450 self.tmin = None
1450 1451 self.tmax = None
1451 1452
1452 1453 self.xmin = None
1453 1454 self.xmax = None
1454 1455
1455 1456 self.figfile = None
1456 1457
1457 1458 def getSubplots(self):
1458 1459
1459 1460 ncol = 1
1460 1461 nrow = self.nplots
1461 1462
1462 1463 return nrow, ncol
1463 1464
1464 1465 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1465 1466
1466 1467 self.__showprofile = showprofile
1467 1468 self.nplots = nplots
1468 1469
1469 1470 ncolspan = 1
1470 1471 colspan = 1
1471 1472
1472 1473 self.createFigure(id = id,
1473 1474 wintitle = wintitle,
1474 1475 widthplot = self.WIDTH + self.WIDTHPROF,
1475 1476 heightplot = self.HEIGHT + self.HEIGHTPROF,
1476 1477 show=show)
1477 1478
1478 1479 nrow, ncol = self.getSubplots()
1479 1480
1480 1481 counter = 0
1481 1482 for y in range(nrow):
1482 1483 if counter >= self.nplots:
1483 1484 break
1484 1485
1485 1486 self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
1486 1487 counter += 1
1487 1488
1488 1489 def run(self, dataOut, id, wintitle="", channelList=None,
1489 1490 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
1490 1491 zmaxVertical = None, zminVertical = None, zmaxZonal = None, zminZonal = None,
1491 1492 timerange=None, SNRthresh = -numpy.inf, SNRmin = None, SNRmax = None, SNR_1 = False,
1492 1493 save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
1493 1494 server=None, folder=None, username=None, password=None,
1494 1495 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1495 1496 """
1496 1497
1497 1498 Input:
1498 1499 dataOut :
1499 1500 id :
1500 1501 wintitle :
1501 1502 channelList :
1502 1503 showProfile :
1503 1504 xmin : None,
1504 1505 xmax : None,
1505 1506 ymin : None,
1506 1507 ymax : None,
1507 1508 zmin : None,
1508 1509 zmax : None
1509 1510 """
1510 1511
1511 1512 if timerange is not None:
1512 1513 self.timerange = timerange
1513 1514
1514 1515 tmin = None
1515 1516 tmax = None
1516 1517
1517 1518 x = dataOut.getTimeRange1(dataOut.outputInterval)
1518 1519 # y = dataOut.heightList
1519 1520 y = dataOut.heightList
1520 1521
1521 1522 z = dataOut.data_output
1522 1523 nplots = z.shape[0] #Number of wind dimensions estimated
1523 1524 nplotsw = nplots
1524 1525
1525 1526 #If there is a SNR function defined
1526 1527 if dataOut.data_SNR is not None:
1527 1528 nplots += 1
1528 1529 SNR = dataOut.data_SNR
1529 1530
1530 1531 if SNR_1:
1531 1532 SNR += 1
1532 1533
1533 1534 SNRavg = numpy.average(SNR, axis=0)
1534 1535
1535 1536 SNRdB = 10*numpy.log10(SNR)
1536 1537 SNRavgdB = 10*numpy.log10(SNRavg)
1537 1538
1538 1539 ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
1539 1540
1540 1541 for i in range(nplotsw):
1541 1542 z[i,ind] = numpy.nan
1542 1543
1543 1544
1544 1545 showprofile = False
1545 1546 # thisDatetime = dataOut.datatime
1546 1547 thisDatetime = datetime.datetime.utcfromtimestamp(x[1])
1547 1548 title = wintitle + " EW Drifts"
1548 1549 xlabel = ""
1549 1550 ylabel = "Height (Km)"
1550 1551
1551 1552 if not self.isConfig:
1552 1553
1553 1554 self.setup(id=id,
1554 1555 nplots=nplots,
1555 1556 wintitle=wintitle,
1556 1557 showprofile=showprofile,
1557 1558 show=show)
1558 1559
1559 1560 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
1560 1561
1561 1562 if ymin == None: ymin = numpy.nanmin(y)
1562 1563 if ymax == None: ymax = numpy.nanmax(y)
1563 1564
1564 1565 if zmaxZonal == None: zmaxZonal = numpy.nanmax(abs(z[0,:]))
1565 1566 if zminZonal == None: zminZonal = -zmaxZonal
1566 1567 if zmaxVertical == None: zmaxVertical = numpy.nanmax(abs(z[1,:]))
1567 1568 if zminVertical == None: zminVertical = -zmaxVertical
1568 1569
1569 1570 if dataOut.data_SNR is not None:
1570 1571 if SNRmin == None: SNRmin = numpy.nanmin(SNRavgdB)
1571 1572 if SNRmax == None: SNRmax = numpy.nanmax(SNRavgdB)
1572 1573
1573 1574 self.FTP_WEI = ftp_wei
1574 1575 self.EXP_CODE = exp_code
1575 1576 self.SUB_EXP_CODE = sub_exp_code
1576 1577 self.PLOT_POS = plot_pos
1577 1578
1578 1579 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1579 1580 self.isConfig = True
1580 1581
1581 1582
1582 1583 self.setWinTitle(title)
1583 1584
1584 1585 if ((self.xmax - x[1]) < (x[1]-x[0])):
1585 1586 x[1] = self.xmax
1586 1587
1587 1588 strWind = ['Zonal','Vertical']
1588 1589 strCb = 'Velocity (m/s)'
1589 1590 zmaxVector = [zmaxZonal, zmaxVertical]
1590 1591 zminVector = [zminZonal, zminVertical]
1591 1592
1592 1593 for i in range(nplotsw):
1593 1594
1594 1595 title = "%s Drifts: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1595 1596 axes = self.axesList[i*self.__nsubplots]
1596 1597
1597 1598 z1 = z[i,:].reshape((1,-1))
1598 1599
1599 1600 axes.pcolorbuffer(x, y, z1,
1600 1601 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
1601 1602 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
1602 1603 ticksize=9, cblabel=strCb, cbsize="1%", colormap="RdBu_r")
1603 1604
1604 1605 if dataOut.data_SNR is not None:
1605 1606 i += 1
1606 1607 if SNR_1:
1607 1608 title = "Signal Noise Ratio + 1 (SNR+1): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1608 1609 else:
1609 1610 title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1610 1611 axes = self.axesList[i*self.__nsubplots]
1611 1612 SNRavgdB = SNRavgdB.reshape((1,-1))
1612 1613
1613 1614 axes.pcolorbuffer(x, y, SNRavgdB,
1614 1615 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
1615 1616 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
1616 1617 ticksize=9, cblabel='', cbsize="1%", colormap="jet")
1617 1618
1618 1619 self.draw()
1619 1620
1620 1621 if x[1] >= self.axesList[0].xmax:
1621 1622 self.counter_imagwr = wr_period
1622 1623 self.isConfig = False
1623 1624 self.figfile = None
1624 1625
1625 1626
1626 1627
1627 1628
1628 1629 class PhasePlot(Figure):
1629 1630
1630 1631 __isConfig = None
1631 1632 __nsubplots = None
1632 1633
1633 1634 PREFIX = 'mphase'
1634 1635
1635 1636 def __init__(self, **kwargs):
1636 1637 Figure.__init__(self, **kwargs)
1637 1638 self.timerange = 24*60*60
1638 1639 self.isConfig = False
1639 1640 self.__nsubplots = 1
1640 1641 self.counter_imagwr = 0
1641 1642 self.WIDTH = 600
1642 1643 self.HEIGHT = 300
1643 1644 self.WIDTHPROF = 120
1644 1645 self.HEIGHTPROF = 0
1645 1646 self.xdata = None
1646 1647 self.ydata = None
1647 1648
1648 1649 self.PLOT_CODE = MPHASE_CODE
1649 1650
1650 1651 self.FTP_WEI = None
1651 1652 self.EXP_CODE = None
1652 1653 self.SUB_EXP_CODE = None
1653 1654 self.PLOT_POS = None
1654 1655
1655 1656
1656 1657 self.filename_phase = None
1657 1658
1658 1659 self.figfile = None
1659 1660
1660 1661 def getSubplots(self):
1661 1662
1662 1663 ncol = 1
1663 1664 nrow = 1
1664 1665
1665 1666 return nrow, ncol
1666 1667
1667 1668 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1668 1669
1669 1670 self.__showprofile = showprofile
1670 1671 self.nplots = nplots
1671 1672
1672 1673 ncolspan = 7
1673 1674 colspan = 6
1674 1675 self.__nsubplots = 2
1675 1676
1676 1677 self.createFigure(id = id,
1677 1678 wintitle = wintitle,
1678 1679 widthplot = self.WIDTH+self.WIDTHPROF,
1679 1680 heightplot = self.HEIGHT+self.HEIGHTPROF,
1680 1681 show=show)
1681 1682
1682 1683 nrow, ncol = self.getSubplots()
1683 1684
1684 1685 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1685 1686
1686 1687
1687 1688 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
1688 1689 xmin=None, xmax=None, ymin=None, ymax=None,
1689 1690 timerange=None,
1690 1691 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
1691 1692 server=None, folder=None, username=None, password=None,
1692 1693 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1693 1694
1694 1695
1695 1696 tmin = None
1696 1697 tmax = None
1697 1698 x = dataOut.getTimeRange1(dataOut.outputInterval)
1698 1699 y = dataOut.getHeiRange()
1699 1700
1700 1701
1701 1702 #thisDatetime = dataOut.datatime
1702 1703 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
1703 1704 title = wintitle + " Phase of Beacon Signal" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
1704 1705 xlabel = "Local Time"
1705 1706 ylabel = "Phase"
1706 1707
1707 1708
1708 1709 #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
1709 1710 phase_beacon = dataOut.data_output
1710 1711 update_figfile = False
1711 1712
1712 1713 if not self.isConfig:
1713 1714
1714 1715 self.nplots = phase_beacon.size
1715 1716
1716 1717 self.setup(id=id,
1717 1718 nplots=self.nplots,
1718 1719 wintitle=wintitle,
1719 1720 showprofile=showprofile,
1720 1721 show=show)
1721 1722
1722 1723 if timerange is not None:
1723 1724 self.timerange = timerange
1724 1725
1725 1726 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
1726 1727
1727 1728 if ymin == None: ymin = numpy.nanmin(phase_beacon) - 10.0
1728 1729 if ymax == None: ymax = numpy.nanmax(phase_beacon) + 10.0
1729 1730
1730 1731 self.FTP_WEI = ftp_wei
1731 1732 self.EXP_CODE = exp_code
1732 1733 self.SUB_EXP_CODE = sub_exp_code
1733 1734 self.PLOT_POS = plot_pos
1734 1735
1735 1736 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1736 1737 self.isConfig = True
1737 1738 self.figfile = figfile
1738 1739 self.xdata = numpy.array([])
1739 1740 self.ydata = numpy.array([])
1740 1741
1741 1742 #open file beacon phase
1742 1743 path = '%s%03d' %(self.PREFIX, self.id)
1743 1744 beacon_file = os.path.join(path,'%s.txt'%self.name)
1744 1745 self.filename_phase = os.path.join(figpath,beacon_file)
1745 1746 update_figfile = True
1746 1747
1747 1748
1748 1749 #store data beacon phase
1749 1750 #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
1750 1751
1751 1752 self.setWinTitle(title)
1752 1753
1753 1754
1754 1755 title = "Phase Offset %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1755 1756
1756 1757 legendlabels = ["phase %d"%(chan) for chan in numpy.arange(self.nplots)]
1757 1758
1758 1759 axes = self.axesList[0]
1759 1760
1760 1761 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1761 1762
1762 1763 if len(self.ydata)==0:
1763 1764 self.ydata = phase_beacon.reshape(-1,1)
1764 1765 else:
1765 1766 self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
1766 1767
1767 1768
1768 1769 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1769 1770 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
1770 1771 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1771 1772 XAxisAsTime=True, grid='both'
1772 1773 )
1773 1774
1774 1775 self.draw()
1775 1776
1776 1777 self.save(figpath=figpath,
1777 1778 figfile=figfile,
1778 1779 save=save,
1779 1780 ftp=ftp,
1780 1781 wr_period=wr_period,
1781 1782 thisDatetime=thisDatetime,
1782 1783 update_figfile=update_figfile)
1783 1784
1784 1785 if dataOut.ltctime + dataOut.outputInterval >= self.xmax:
1785 1786 self.counter_imagwr = wr_period
1786 1787 self.isConfig = False
1787 1788 update_figfile = True
1788 1789
1789 1790
1790 1791
1791 1792 class NSMeteorDetection1Plot(Figure):
1792 1793
1793 1794 isConfig = None
1794 1795 __nsubplots = None
1795 1796
1796 1797 WIDTHPROF = None
1797 1798 HEIGHTPROF = None
1798 1799 PREFIX = 'nsm'
1799 1800
1800 1801 zminList = None
1801 1802 zmaxList = None
1802 1803 cmapList = None
1803 1804 titleList = None
1804 1805 nPairs = None
1805 1806 nChannels = None
1806 1807 nParam = None
1807 1808
1808 1809 def __init__(self, **kwargs):
1809 1810 Figure.__init__(self, **kwargs)
1810 1811 self.isConfig = False
1811 1812 self.__nsubplots = 1
1812 1813
1813 1814 self.WIDTH = 750
1814 1815 self.HEIGHT = 250
1815 1816 self.WIDTHPROF = 120
1816 1817 self.HEIGHTPROF = 0
1817 1818 self.counter_imagwr = 0
1818 1819
1819 1820 self.PLOT_CODE = SPEC_CODE
1820 1821
1821 1822 self.FTP_WEI = None
1822 1823 self.EXP_CODE = None
1823 1824 self.SUB_EXP_CODE = None
1824 1825 self.PLOT_POS = None
1825 1826
1826 1827 self.__xfilter_ena = False
1827 1828 self.__yfilter_ena = False
1828 1829
1829 1830 def getSubplots(self):
1830 1831
1831 1832 ncol = 3
1832 1833 nrow = int(numpy.ceil(self.nplots/3.0))
1833 1834
1834 1835 return nrow, ncol
1835 1836
1836 1837 def setup(self, id, nplots, wintitle, show=True):
1837 1838
1838 1839 self.nplots = nplots
1839 1840
1840 1841 ncolspan = 1
1841 1842 colspan = 1
1842 1843
1843 1844 self.createFigure(id = id,
1844 1845 wintitle = wintitle,
1845 1846 widthplot = self.WIDTH + self.WIDTHPROF,
1846 1847 heightplot = self.HEIGHT + self.HEIGHTPROF,
1847 1848 show=show)
1848 1849
1849 1850 nrow, ncol = self.getSubplots()
1850 1851
1851 1852 counter = 0
1852 1853 for y in range(nrow):
1853 1854 for x in range(ncol):
1854 1855
1855 1856 if counter >= self.nplots:
1856 1857 break
1857 1858
1858 1859 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
1859 1860
1860 1861 counter += 1
1861 1862
1862 1863 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
1863 1864 xmin=None, xmax=None, ymin=None, ymax=None, SNRmin=None, SNRmax=None,
1864 1865 vmin=None, vmax=None, wmin=None, wmax=None, mode = 'SA',
1865 1866 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
1866 1867 server=None, folder=None, username=None, password=None,
1867 1868 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
1868 1869 xaxis="frequency"):
1869 1870
1870 1871 """
1871 1872
1872 1873 Input:
1873 1874 dataOut :
1874 1875 id :
1875 1876 wintitle :
1876 1877 channelList :
1877 1878 showProfile :
1878 1879 xmin : None,
1879 1880 xmax : None,
1880 1881 ymin : None,
1881 1882 ymax : None,
1882 1883 zmin : None,
1883 1884 zmax : None
1884 1885 """
1885 1886 #SEPARAR EN DOS PLOTS
1886 1887 nParam = dataOut.data_param.shape[1] - 3
1887 1888
1888 1889 utctime = dataOut.data_param[0,0]
1889 1890 tmet = dataOut.data_param[:,1].astype(int)
1890 1891 hmet = dataOut.data_param[:,2].astype(int)
1891 1892
1892 1893 x = dataOut.abscissaList
1893 1894 y = dataOut.heightList
1894 1895
1895 1896 z = numpy.zeros((nParam, y.size, x.size - 1))
1896 1897 z[:,:] = numpy.nan
1897 1898 z[:,hmet,tmet] = dataOut.data_param[:,3:].T
1898 1899 z[0,:,:] = 10*numpy.log10(z[0,:,:])
1899 1900
1900 1901 xlabel = "Time (s)"
1901 1902 ylabel = "Range (km)"
1902 1903
1903 1904 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
1904 1905
1905 1906 if not self.isConfig:
1906 1907
1907 1908 nplots = nParam
1908 1909
1909 1910 self.setup(id=id,
1910 1911 nplots=nplots,
1911 1912 wintitle=wintitle,
1912 1913 show=show)
1913 1914
1914 1915 if xmin is None: xmin = numpy.nanmin(x)
1915 1916 if xmax is None: xmax = numpy.nanmax(x)
1916 1917 if ymin is None: ymin = numpy.nanmin(y)
1917 1918 if ymax is None: ymax = numpy.nanmax(y)
1918 1919 if SNRmin is None: SNRmin = numpy.nanmin(z[0,:])
1919 1920 if SNRmax is None: SNRmax = numpy.nanmax(z[0,:])
1920 1921 if vmax is None: vmax = numpy.nanmax(numpy.abs(z[1,:]))
1921 1922 if vmin is None: vmin = -vmax
1922 1923 if wmin is None: wmin = 0
1923 1924 if wmax is None: wmax = 50
1924 1925
1925 1926 pairsList = dataOut.groupList
1926 1927 self.nPairs = len(dataOut.groupList)
1927 1928
1928 1929 zminList = [SNRmin, vmin, cmin] + [pmin]*self.nPairs
1929 1930 zmaxList = [SNRmax, vmax, cmax] + [pmax]*self.nPairs
1930 1931 titleList = ["SNR","Radial Velocity","Coherence"]
1931 1932 cmapList = ["jet","RdBu_r","jet"]
1932 1933
1933 1934 for i in range(self.nPairs):
1934 1935 strAux1 = "Phase Difference "+ str(pairsList[i][0]) + str(pairsList[i][1])
1935 1936 titleList = titleList + [strAux1]
1936 1937 cmapList = cmapList + ["RdBu_r"]
1937 1938
1938 1939 self.zminList = zminList
1939 1940 self.zmaxList = zmaxList
1940 1941 self.cmapList = cmapList
1941 1942 self.titleList = titleList
1942 1943
1943 1944 self.FTP_WEI = ftp_wei
1944 1945 self.EXP_CODE = exp_code
1945 1946 self.SUB_EXP_CODE = sub_exp_code
1946 1947 self.PLOT_POS = plot_pos
1947 1948
1948 1949 self.isConfig = True
1949 1950
1950 1951 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
1951 1952
1952 1953 for i in range(nParam):
1953 1954 title = self.titleList[i] + ": " +str_datetime
1954 1955 axes = self.axesList[i]
1955 1956 axes.pcolor(x, y, z[i,:].T,
1956 1957 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=self.zminList[i], zmax=self.zmaxList[i],
1957 1958 xlabel=xlabel, ylabel=ylabel, title=title, colormap=self.cmapList[i],ticksize=9, cblabel='')
1958 1959 self.draw()
1959 1960
1960 1961 if figfile == None:
1961 1962 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
1962 1963 name = str_datetime
1963 1964 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
1964 1965 name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
1965 1966 figfile = self.getFilename(name)
1966 1967
1967 1968 self.save(figpath=figpath,
1968 1969 figfile=figfile,
1969 1970 save=save,
1970 1971 ftp=ftp,
1971 1972 wr_period=wr_period,
1972 1973 thisDatetime=thisDatetime)
1973 1974
1974 1975
1975 1976 class NSMeteorDetection2Plot(Figure):
1976 1977
1977 1978 isConfig = None
1978 1979 __nsubplots = None
1979 1980
1980 1981 WIDTHPROF = None
1981 1982 HEIGHTPROF = None
1982 1983 PREFIX = 'nsm'
1983 1984
1984 1985 zminList = None
1985 1986 zmaxList = None
1986 1987 cmapList = None
1987 1988 titleList = None
1988 1989 nPairs = None
1989 1990 nChannels = None
1990 1991 nParam = None
1991 1992
1992 1993 def __init__(self, **kwargs):
1993 1994 Figure.__init__(self, **kwargs)
1994 1995 self.isConfig = False
1995 1996 self.__nsubplots = 1
1996 1997
1997 1998 self.WIDTH = 750
1998 1999 self.HEIGHT = 250
1999 2000 self.WIDTHPROF = 120
2000 2001 self.HEIGHTPROF = 0
2001 2002 self.counter_imagwr = 0
2002 2003
2003 2004 self.PLOT_CODE = SPEC_CODE
2004 2005
2005 2006 self.FTP_WEI = None
2006 2007 self.EXP_CODE = None
2007 2008 self.SUB_EXP_CODE = None
2008 2009 self.PLOT_POS = None
2009 2010
2010 2011 self.__xfilter_ena = False
2011 2012 self.__yfilter_ena = False
2012 2013
2013 2014 def getSubplots(self):
2014 2015
2015 2016 ncol = 3
2016 2017 nrow = int(numpy.ceil(self.nplots/3.0))
2017 2018
2018 2019 return nrow, ncol
2019 2020
2020 2021 def setup(self, id, nplots, wintitle, show=True):
2021 2022
2022 2023 self.nplots = nplots
2023 2024
2024 2025 ncolspan = 1
2025 2026 colspan = 1
2026 2027
2027 2028 self.createFigure(id = id,
2028 2029 wintitle = wintitle,
2029 2030 widthplot = self.WIDTH + self.WIDTHPROF,
2030 2031 heightplot = self.HEIGHT + self.HEIGHTPROF,
2031 2032 show=show)
2032 2033
2033 2034 nrow, ncol = self.getSubplots()
2034 2035
2035 2036 counter = 0
2036 2037 for y in range(nrow):
2037 2038 for x in range(ncol):
2038 2039
2039 2040 if counter >= self.nplots:
2040 2041 break
2041 2042
2042 2043 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
2043 2044
2044 2045 counter += 1
2045 2046
2046 2047 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
2047 2048 xmin=None, xmax=None, ymin=None, ymax=None, SNRmin=None, SNRmax=None,
2048 2049 vmin=None, vmax=None, wmin=None, wmax=None, mode = 'SA',
2049 2050 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
2050 2051 server=None, folder=None, username=None, password=None,
2051 2052 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
2052 2053 xaxis="frequency"):
2053 2054
2054 2055 """
2055 2056
2056 2057 Input:
2057 2058 dataOut :
2058 2059 id :
2059 2060 wintitle :
2060 2061 channelList :
2061 2062 showProfile :
2062 2063 xmin : None,
2063 2064 xmax : None,
2064 2065 ymin : None,
2065 2066 ymax : None,
2066 2067 zmin : None,
2067 2068 zmax : None
2068 2069 """
2069 2070 #Rebuild matrix
2070 2071 utctime = dataOut.data_param[0,0]
2071 2072 cmet = dataOut.data_param[:,1].astype(int)
2072 2073 tmet = dataOut.data_param[:,2].astype(int)
2073 2074 hmet = dataOut.data_param[:,3].astype(int)
2074 2075
2075 2076 nParam = 3
2076 2077 nChan = len(dataOut.groupList)
2077 2078 x = dataOut.abscissaList
2078 2079 y = dataOut.heightList
2079 2080
2080 2081 z = numpy.full((nChan, nParam, y.size, x.size - 1),numpy.nan)
2081 2082 z[cmet,:,hmet,tmet] = dataOut.data_param[:,4:]
2082 2083 z[:,0,:,:] = 10*numpy.log10(z[:,0,:,:]) #logarithmic scale
2083 2084 z = numpy.reshape(z, (nChan*nParam, y.size, x.size-1))
2084 2085
2085 2086 xlabel = "Time (s)"
2086 2087 ylabel = "Range (km)"
2087 2088
2088 2089 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
2089 2090
2090 2091 if not self.isConfig:
2091 2092
2092 2093 nplots = nParam*nChan
2093 2094
2094 2095 self.setup(id=id,
2095 2096 nplots=nplots,
2096 2097 wintitle=wintitle,
2097 2098 show=show)
2098 2099
2099 2100 if xmin is None: xmin = numpy.nanmin(x)
2100 2101 if xmax is None: xmax = numpy.nanmax(x)
2101 2102 if ymin is None: ymin = numpy.nanmin(y)
2102 2103 if ymax is None: ymax = numpy.nanmax(y)
2103 2104 if SNRmin is None: SNRmin = numpy.nanmin(z[0,:])
2104 2105 if SNRmax is None: SNRmax = numpy.nanmax(z[0,:])
2105 2106 if vmax is None: vmax = numpy.nanmax(numpy.abs(z[1,:]))
2106 2107 if vmin is None: vmin = -vmax
2107 2108 if wmin is None: wmin = 0
2108 2109 if wmax is None: wmax = 50
2109 2110
2110 2111 self.nChannels = nChan
2111 2112
2112 2113 zminList = []
2113 2114 zmaxList = []
2114 2115 titleList = []
2115 2116 cmapList = []
2116 2117 for i in range(self.nChannels):
2117 2118 strAux1 = "SNR Channel "+ str(i)
2118 2119 strAux2 = "Radial Velocity Channel "+ str(i)
2119 2120 strAux3 = "Spectral Width Channel "+ str(i)
2120 2121
2121 2122 titleList = titleList + [strAux1,strAux2,strAux3]
2122 2123 cmapList = cmapList + ["jet","RdBu_r","jet"]
2123 2124 zminList = zminList + [SNRmin,vmin,wmin]
2124 2125 zmaxList = zmaxList + [SNRmax,vmax,wmax]
2125 2126
2126 2127 self.zminList = zminList
2127 2128 self.zmaxList = zmaxList
2128 2129 self.cmapList = cmapList
2129 2130 self.titleList = titleList
2130 2131
2131 2132 self.FTP_WEI = ftp_wei
2132 2133 self.EXP_CODE = exp_code
2133 2134 self.SUB_EXP_CODE = sub_exp_code
2134 2135 self.PLOT_POS = plot_pos
2135 2136
2136 2137 self.isConfig = True
2137 2138
2138 2139 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
2139 2140
2140 2141 for i in range(self.nplots):
2141 2142 title = self.titleList[i] + ": " +str_datetime
2142 2143 axes = self.axesList[i]
2143 2144 axes.pcolor(x, y, z[i,:].T,
2144 2145 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=self.zminList[i], zmax=self.zmaxList[i],
2145 2146 xlabel=xlabel, ylabel=ylabel, title=title, colormap=self.cmapList[i],ticksize=9, cblabel='')
2146 2147 self.draw()
2147 2148
2148 2149 if figfile == None:
2149 2150 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
2150 2151 name = str_datetime
2151 2152 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
2152 2153 name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
2153 2154 figfile = self.getFilename(name)
2154 2155
2155 2156 self.save(figpath=figpath,
2156 2157 figfile=figfile,
2157 2158 save=save,
2158 2159 ftp=ftp,
2159 2160 wr_period=wr_period,
2160 2161 thisDatetime=thisDatetime)
Show file before | Show file after | Hide comments
@@ -1,1605 +1,1605
1 1 '''
2 2 Created on Jul 9, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 6 import os
7 7 import datetime
8 8 import numpy
9 9
10 10 import matplotlib.pyplot as plt
11 11
12 12 from figure import Figure, isRealtime, isTimeInHourRange
13 13 from plotting_codes import *
14 14 from matplotlib.pyplot import savefig
15 15
16 16 class SpectraPlot(Figure):
17 17
18 18 isConfig = None
19 19 __nsubplots = None
20 20
21 21 WIDTHPROF = None
22 22 HEIGHTPROF = None
23 23 PREFIX = 'spc'
24 24
25 25 def __init__(self, **kwargs):
26 26 Figure.__init__(self, **kwargs)
27 27 self.isConfig = False
28 28 self.__nsubplots = 1
29 29
30 30 self.WIDTH = 300
31 31 self.HEIGHT = 300
32 32 self.WIDTHPROF = 120
33 33 self.HEIGHTPROF = 0
34 34 self.counter_imagwr = 0
35 35
36 36 self.PLOT_CODE = SPEC_CODE
37 37
38 38 self.FTP_WEI = None
39 39 self.EXP_CODE = None
40 40 self.SUB_EXP_CODE = None
41 41 self.PLOT_POS = None
42 42
43 43 self.__xfilter_ena = False
44 44 self.__yfilter_ena = False
45 45
46 46 self.indice=1
47 47
48 48 def getSubplots(self):
49 49
50 50 ncol = int(numpy.sqrt(self.nplots)+0.9)
51 51 nrow = int(self.nplots*1./ncol + 0.9)
52 52
53 53 return nrow, ncol
54 54
55 55 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
56 56
57 57 self.__showprofile = showprofile
58 58 self.nplots = nplots
59 59
60 60 ncolspan = 1
61 61 colspan = 1
62 62 if showprofile:
63 63 ncolspan = 3
64 64 colspan = 2
65 65 self.__nsubplots = 2
66 66
67 67 self.createFigure(id = id,
68 68 wintitle = wintitle,
69 69 widthplot = self.WIDTH + self.WIDTHPROF,
70 70 heightplot = self.HEIGHT + self.HEIGHTPROF,
71 71 show=show)
72 72
73 73 nrow, ncol = self.getSubplots()
74 74
75 75 counter = 0
76 76 for y in range(nrow):
77 77 for x in range(ncol):
78 78
79 79 if counter >= self.nplots:
80 80 break
81 81
82 82 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
83 83
84 84 if showprofile:
85 85 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
86 86
87 87 counter += 1
88 88
89 89 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
90 90 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
91 91 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
92 92 server=None, folder=None, username=None, password=None,
93 93 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
94 94 xaxis="frequency", colormap='jet', normFactor=None):
95 95
96 96 """
97 97
98 98 Input:
99 99 dataOut :
100 100 id :
101 101 wintitle :
102 102 channelList :
103 103 showProfile :
104 104 xmin : None,
105 105 xmax : None,
106 106 ymin : None,
107 107 ymax : None,
108 108 zmin : None,
109 109 zmax : None
110 110 """
111 111 if realtime:
112 112 if not(isRealtime(utcdatatime = dataOut.utctime)):
113 113 print 'Skipping this plot function'
114 114 return
115 115
116 116 if channelList == None:
117 117 channelIndexList = dataOut.channelIndexList
118 118 else:
119 119 channelIndexList = []
120 120 for channel in channelList:
121 121 if channel not in dataOut.channelList:
122 122 raise ValueError, "Channel %d is not in dataOut.channelList" %channel
123 123 channelIndexList.append(dataOut.channelList.index(channel))
124 124
125 125 if normFactor is None:
126 126 factor = dataOut.normFactor
127 127 else:
128 128 factor = normFactor
129 129 if xaxis == "frequency":
130 130 x = dataOut.getFreqRange(1)/1000.
131 131 xlabel = "Frequency (kHz)"
132 132
133 133 elif xaxis == "time":
134 134 x = dataOut.getAcfRange(1)
135 135 xlabel = "Time (ms)"
136 136
137 137 else:
138 138 x = dataOut.getVelRange(1)
139 139 xlabel = "Velocity (m/s)"
140 140
141 141 ylabel = "Range (Km)"
142 142
143 143 y = dataOut.getHeiRange()
144
144 print 'dataOut.normFactor', dataOut.normFactor
145 145 z = dataOut.data_spc/factor
146 146 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
147 147 zdB = 10*numpy.log10(z)
148 148
149 149 avg = numpy.average(z, axis=1)
150 150 avgdB = 10*numpy.log10(avg)
151 151
152 152 noise = dataOut.getNoise()/factor
153 153 noisedB = 10*numpy.log10(noise)
154 154
155 155 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
156 156 title = wintitle + " Spectra"
157 157
158 158
159 159
160 160 print 'len de X',len(x), numpy.shape(x), 'len de spc line',len(dataOut.data_spc[1,:,15]), numpy.shape(dataOut.data_spc)
161 161 print 'Altura:', y[0], y[1], y[13], y[14], y[10]
162 162 #a=z[1,:,15]
163 163
164 164 # fig = plt.figure(10+self.indice)
165 165 # plt.plot( x[0:128], zdB[0,:,10] )
166 166 # plt.axis([-12, 12, 15, 50])
167 167 # plt.title(" %s" %( '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))) )
168 168 # plt.ylabel('Intensidad [dB]')
169 169 # plt.xlabel('Velocidad [m/s]')
170 170 # fig.savefig('/home/erick/Documents/Pics/to{}.png'.format(self.indice))
171 171 #
172 172 # plt.show()
173 173 #
174 174 # self.indice=self.indice+1
175 175
176 176
177 177
178 178 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
179 179 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
180 180
181 181 if not self.isConfig:
182 182
183 183 nplots = len(channelIndexList)
184 184
185 185 self.setup(id=id,
186 186 nplots=nplots,
187 187 wintitle=wintitle,
188 188 showprofile=showprofile,
189 189 show=show)
190 190
191 191 if xmin == None: xmin = numpy.nanmin(x)
192 192 if xmax == None: xmax = numpy.nanmax(x)
193 193 if ymin == None: ymin = numpy.nanmin(y)
194 194 if ymax == None: ymax = numpy.nanmax(y)
195 195 if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
196 196 if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
197 197
198 198 self.FTP_WEI = ftp_wei
199 199 self.EXP_CODE = exp_code
200 200 self.SUB_EXP_CODE = sub_exp_code
201 201 self.PLOT_POS = plot_pos
202 202
203 203 self.isConfig = True
204 204
205 205 self.setWinTitle(title)
206 206
207 207 for i in range(self.nplots):
208 208 index = channelIndexList[i]
209 209 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
210 210 title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[index], noisedB[index], str_datetime)
211 211 if len(dataOut.beam.codeList) != 0:
212 212 title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[index], noisedB[index], dataOut.beam.azimuthList[index], dataOut.beam.zenithList[index], str_datetime)
213 213
214 214 axes = self.axesList[i*self.__nsubplots]
215 215 axes.pcolor(x, y, zdB[index,:,:],
216 216 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
217 217 xlabel=xlabel, ylabel=ylabel, title=title, colormap=colormap,
218 218 ticksize=9, cblabel='')
219 219
220 220 if self.__showprofile:
221 221 axes = self.axesList[i*self.__nsubplots +1]
222 222 axes.pline(avgdB[index,:], y,
223 223 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
224 224 xlabel='dB', ylabel='', title='',
225 225 ytick_visible=False,
226 226 grid='x')
227 227
228 228 noiseline = numpy.repeat(noisedB[index], len(y))
229 229 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
230 230
231 231 self.draw()
232 232
233 233 if figfile == None:
234 234 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
235 235 name = str_datetime
236 236 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
237 237 name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
238 238 figfile = self.getFilename(name)
239 239
240 240 self.save(figpath=figpath,
241 241 figfile=figfile,
242 242 save=save,
243 243 ftp=ftp,
244 244 wr_period=wr_period,
245 245 thisDatetime=thisDatetime)
246 246
247 247
248 248 class CrossSpectraPlot(Figure):
249 249
250 250 isConfig = None
251 251 __nsubplots = None
252 252
253 253 WIDTH = None
254 254 HEIGHT = None
255 255 WIDTHPROF = None
256 256 HEIGHTPROF = None
257 257 PREFIX = 'cspc'
258 258
259 259 def __init__(self, **kwargs):
260 260 Figure.__init__(self, **kwargs)
261 261 self.isConfig = False
262 262 self.__nsubplots = 4
263 263 self.counter_imagwr = 0
264 264 self.WIDTH = 250
265 265 self.HEIGHT = 250
266 266 self.WIDTHPROF = 0
267 267 self.HEIGHTPROF = 0
268 268
269 269 self.PLOT_CODE = CROSS_CODE
270 270 self.FTP_WEI = None
271 271 self.EXP_CODE = None
272 272 self.SUB_EXP_CODE = None
273 273 self.PLOT_POS = None
274 274
275 275 self.indice=0
276 276
277 277 def getSubplots(self):
278 278
279 279 ncol = 4
280 280 nrow = self.nplots
281 281
282 282 return nrow, ncol
283 283
284 284 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
285 285
286 286 self.__showprofile = showprofile
287 287 self.nplots = nplots
288 288
289 289 ncolspan = 1
290 290 colspan = 1
291 291
292 292 self.createFigure(id = id,
293 293 wintitle = wintitle,
294 294 widthplot = self.WIDTH + self.WIDTHPROF,
295 295 heightplot = self.HEIGHT + self.HEIGHTPROF,
296 296 show=True)
297 297
298 298 nrow, ncol = self.getSubplots()
299 299
300 300 counter = 0
301 301 for y in range(nrow):
302 302 for x in range(ncol):
303 303 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
304 304
305 305 counter += 1
306 306
307 307 def run(self, dataOut, id, wintitle="", pairsList=None,
308 308 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
309 309 coh_min=None, coh_max=None, phase_min=None, phase_max=None,
310 310 save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
311 311 power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
312 312 server=None, folder=None, username=None, password=None,
313 313 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None,
314 314 xaxis='frequency'):
315 315
316 316 """
317 317
318 318 Input:
319 319 dataOut :
320 320 id :
321 321 wintitle :
322 322 channelList :
323 323 showProfile :
324 324 xmin : None,
325 325 xmax : None,
326 326 ymin : None,
327 327 ymax : None,
328 328 zmin : None,
329 329 zmax : None
330 330 """
331 331
332 332 if pairsList == None:
333 333 pairsIndexList = dataOut.pairsIndexList
334 334 else:
335 335 pairsIndexList = []
336 336 for pair in pairsList:
337 337 if pair not in dataOut.pairsList:
338 338 raise ValueError, "Pair %s is not in dataOut.pairsList" %str(pair)
339 339 pairsIndexList.append(dataOut.pairsList.index(pair))
340 340
341 341 if not pairsIndexList:
342 342 return
343 343
344 344 if len(pairsIndexList) > 4:
345 345 pairsIndexList = pairsIndexList[0:4]
346 346
347 347 if normFactor is None:
348 348 factor = dataOut.normFactor
349 349 else:
350 350 factor = normFactor
351 351 x = dataOut.getVelRange(1)
352 352 y = dataOut.getHeiRange()
353 353 z = dataOut.data_spc[:,:,:]/factor
354 354 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
355 355
356 356 noise = dataOut.noise/factor
357 357
358 358 zdB = 10*numpy.log10(z)
359 359 noisedB = 10*numpy.log10(noise)
360 360
361 361 if coh_min == None:
362 362 coh_min = 0.0
363 363 if coh_max == None:
364 364 coh_max = 1.0
365 365
366 366 if phase_min == None:
367 367 phase_min = -180
368 368 if phase_max == None:
369 369 phase_max = 180
370 370
371 371 #thisDatetime = dataOut.datatime
372 372 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
373 373 title = wintitle + " Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
374 374 # xlabel = "Velocity (m/s)"
375 375 ylabel = "Range (Km)"
376 376
377 377 if xaxis == "frequency":
378 378 x = dataOut.getFreqRange(1)/1000.
379 379 xlabel = "Frequency (kHz)"
380 380
381 381 elif xaxis == "time":
382 382 x = dataOut.getAcfRange(1)
383 383 xlabel = "Time (ms)"
384 384
385 385 else:
386 386 x = dataOut.getVelRange(1)
387 387 xlabel = "Velocity (m/s)"
388 388
389 389 if not self.isConfig:
390 390
391 391 nplots = len(pairsIndexList)
392 392
393 393 self.setup(id=id,
394 394 nplots=nplots,
395 395 wintitle=wintitle,
396 396 showprofile=False,
397 397 show=show)
398 398
399 399 avg = numpy.abs(numpy.average(z, axis=1))
400 400 avgdB = 10*numpy.log10(avg)
401 401
402 402 if xmin == None: xmin = numpy.nanmin(x)
403 403 if xmax == None: xmax = numpy.nanmax(x)
404 404 if ymin == None: ymin = numpy.nanmin(y)
405 405 if ymax == None: ymax = numpy.nanmax(y)
406 406 if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
407 407 if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
408 408
409 409 self.FTP_WEI = ftp_wei
410 410 self.EXP_CODE = exp_code
411 411 self.SUB_EXP_CODE = sub_exp_code
412 412 self.PLOT_POS = plot_pos
413 413
414 414 self.isConfig = True
415 415
416 416 self.setWinTitle(title)
417 417
418 418
419 419 for i in range(self.nplots):
420 420 pair = dataOut.pairsList[pairsIndexList[i]]
421 421
422 422 chan_index0 = dataOut.channelList.index(pair[0])
423 423 chan_index1 = dataOut.channelList.index(pair[1])
424 424
425 425 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
426 426 title = "Ch%d: %4.2fdB: %s" %(pair[0], noisedB[chan_index0], str_datetime)
427 427 zdB = 10.*numpy.log10(dataOut.data_spc[chan_index0,:,:]/factor)
428 428 axes0 = self.axesList[i*self.__nsubplots]
429 429 axes0.pcolor(x, y, zdB,
430 430 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
431 431 xlabel=xlabel, ylabel=ylabel, title=title,
432 432 ticksize=9, colormap=power_cmap, cblabel='')
433 433
434 434 title = "Ch%d: %4.2fdB: %s" %(pair[1], noisedB[chan_index1], str_datetime)
435 435 zdB = 10.*numpy.log10(dataOut.data_spc[chan_index1,:,:]/factor)
436 436 axes0 = self.axesList[i*self.__nsubplots+1]
437 437 axes0.pcolor(x, y, zdB,
438 438 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
439 439 xlabel=xlabel, ylabel=ylabel, title=title,
440 440 ticksize=9, colormap=power_cmap, cblabel='')
441 441
442 442 coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:] / numpy.sqrt( dataOut.data_spc[chan_index0,:,:]*dataOut.data_spc[chan_index1,:,:] )
443 443 coherence = numpy.abs(coherenceComplex)
444 444 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
445 445 phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
446 446
447 447
448 448
449 449
450 450 # #print 'FASE', numpy.shape(phase), y[25]
451 451 # fig = plt.figure(10+self.indice)
452 452 # #plt.plot( x[0:256],coherence[:,25] )
453 453 # cohAv = numpy.average(coherence,1)
454 454 #
455 455 # plt.plot( x[0:256],cohAv )
456 456 # #plt.axis([-12, 12, 15, 50])
457 457 # plt.title("%s" %( '%s %s, Channel %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S") , i)))
458 458 # plt.ylabel('Desfase [grados]')
459 459 # plt.xlabel('Velocidad [m/s]')
460 460 # fig.savefig('/home/erick/Documents/Pics/to{}.png'.format(self.indice))
461 461 #
462 462 # plt.show()
463 463 # self.indice=self.indice+1
464 464
465 465
466 466 # print 'FASE', numpy.shape(phase), y[25]
467 467 # fig = plt.figure(10+self.indice)
468 468 # plt.plot( x[0:256],phase[:,25] )
469 469 # #plt.axis([-12, 12, 15, 50])
470 470 # plt.title("%s" %( '%s %s, Channel %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S") , i)))
471 471 # plt.ylabel('Desfase [grados]')
472 472 # plt.xlabel('Velocidad [m/s]')
473 473 # fig.savefig('/home/erick/Documents/Pics/to{}.png'.format(self.indice))
474 474 #
475 475 # plt.show()
476 476 # self.indice=self.indice+1
477 477
478 478
479 479
480 480
481 481 title = "Coherence Ch%d * Ch%d" %(pair[0], pair[1])
482 482 axes0 = self.axesList[i*self.__nsubplots+2]
483 483 axes0.pcolor(x, y, coherence,
484 484 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=coh_min, zmax=coh_max,
485 485 xlabel=xlabel, ylabel=ylabel, title=title,
486 486 ticksize=9, colormap=coherence_cmap, cblabel='')
487 487
488 488 title = "Phase Ch%d * Ch%d" %(pair[0], pair[1])
489 489 axes0 = self.axesList[i*self.__nsubplots+3]
490 490 axes0.pcolor(x, y, phase,
491 491 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=phase_min, zmax=phase_max,
492 492 xlabel=xlabel, ylabel=ylabel, title=title,
493 493 ticksize=9, colormap=phase_cmap, cblabel='')
494 494
495 495
496 496
497 497 self.draw()
498 498
499 499 self.save(figpath=figpath,
500 500 figfile=figfile,
501 501 save=save,
502 502 ftp=ftp,
503 503 wr_period=wr_period,
504 504 thisDatetime=thisDatetime)
505 505
506 506
507 507 class RTIPlot(Figure):
508 508
509 509 __isConfig = None
510 510 __nsubplots = None
511 511
512 512 WIDTHPROF = None
513 513 HEIGHTPROF = None
514 514 PREFIX = 'rti'
515 515
516 516 def __init__(self, **kwargs):
517 517
518 518 Figure.__init__(self, **kwargs)
519 519 self.timerange = None
520 520 self.isConfig = False
521 521 self.__nsubplots = 1
522 522
523 523 self.WIDTH = 800
524 524 self.HEIGHT = 250
525 525 self.WIDTHPROF = 120
526 526 self.HEIGHTPROF = 0
527 527 self.counter_imagwr = 0
528 528
529 529 self.PLOT_CODE = RTI_CODE
530 530
531 531 self.FTP_WEI = None
532 532 self.EXP_CODE = None
533 533 self.SUB_EXP_CODE = None
534 534 self.PLOT_POS = None
535 535 self.tmin = None
536 536 self.tmax = None
537 537
538 538 self.xmin = None
539 539 self.xmax = None
540 540
541 541 self.figfile = None
542 542
543 543 def getSubplots(self):
544 544
545 545 ncol = 1
546 546 nrow = self.nplots
547 547
548 548 return nrow, ncol
549 549
550 550 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
551 551
552 552 self.__showprofile = showprofile
553 553 self.nplots = nplots
554 554
555 555 ncolspan = 1
556 556 colspan = 1
557 557 if showprofile:
558 558 ncolspan = 7
559 559 colspan = 6
560 560 self.__nsubplots = 2
561 561
562 562 self.createFigure(id = id,
563 563 wintitle = wintitle,
564 564 widthplot = self.WIDTH + self.WIDTHPROF,
565 565 heightplot = self.HEIGHT + self.HEIGHTPROF,
566 566 show=show)
567 567
568 568 nrow, ncol = self.getSubplots()
569 569
570 570 counter = 0
571 571 for y in range(nrow):
572 572 for x in range(ncol):
573 573
574 574 if counter >= self.nplots:
575 575 break
576 576
577 577 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
578 578
579 579 if showprofile:
580 580 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
581 581
582 582 counter += 1
583 583
584 584 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
585 585 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
586 586 timerange=None, colormap='jet',
587 587 save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
588 588 server=None, folder=None, username=None, password=None,
589 589 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None, HEIGHT=None):
590 590
591 591 """
592 592
593 593 Input:
594 594 dataOut :
595 595 id :
596 596 wintitle :
597 597 channelList :
598 598 showProfile :
599 599 xmin : None,
600 600 xmax : None,
601 601 ymin : None,
602 602 ymax : None,
603 603 zmin : None,
604 604 zmax : None
605 605 """
606 606
607 607 #colormap = kwargs.get('colormap', 'jet')
608 608 if HEIGHT is not None:
609 609 self.HEIGHT = HEIGHT
610 610
611 611 if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
612 612 return
613 613
614 614 if channelList == None:
615 615 channelIndexList = dataOut.channelIndexList
616 616 else:
617 617 channelIndexList = []
618 618 for channel in channelList:
619 619 if channel not in dataOut.channelList:
620 620 raise ValueError, "Channel %d is not in dataOut.channelList"
621 621 channelIndexList.append(dataOut.channelList.index(channel))
622 622
623 623 if normFactor is None:
624 624 factor = dataOut.normFactor
625 625 else:
626 626 factor = normFactor
627 627
628 628 # factor = dataOut.normFactor
629 629 x = dataOut.getTimeRange()
630 630 y = dataOut.getHeiRange()
631 631
632 632 z = dataOut.data_spc/factor
633 633 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
634 634 avg = numpy.average(z, axis=1)
635 635 avgdB = 10.*numpy.log10(avg)
636 636 # avgdB = dataOut.getPower()
637 637
638 638
639 639 thisDatetime = dataOut.datatime
640 640 # thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
641 641 title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
642 642 xlabel = ""
643 643 ylabel = "Range (Km)"
644 644
645 645 update_figfile = False
646 646
647 647 if dataOut.ltctime >= self.xmax:
648 648 self.counter_imagwr = wr_period
649 649 self.isConfig = False
650 650 update_figfile = True
651 651
652 652 if not self.isConfig:
653 653
654 654 nplots = len(channelIndexList)
655 655
656 656 self.setup(id=id,
657 657 nplots=nplots,
658 658 wintitle=wintitle,
659 659 showprofile=showprofile,
660 660 show=show)
661 661
662 662 if timerange != None:
663 663 self.timerange = timerange
664 664
665 665 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
666 666
667 667 noise = dataOut.noise/factor
668 668 noisedB = 10*numpy.log10(noise)
669 669
670 670 if ymin == None: ymin = numpy.nanmin(y)
671 671 if ymax == None: ymax = numpy.nanmax(y)
672 672 if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
673 673 if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
674 674
675 675 self.FTP_WEI = ftp_wei
676 676 self.EXP_CODE = exp_code
677 677 self.SUB_EXP_CODE = sub_exp_code
678 678 self.PLOT_POS = plot_pos
679 679
680 680 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
681 681 self.isConfig = True
682 682 self.figfile = figfile
683 683 update_figfile = True
684 684
685 685 self.setWinTitle(title)
686 686
687 687 for i in range(self.nplots):
688 688 index = channelIndexList[i]
689 689 title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
690 690 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
691 691 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
692 692 axes = self.axesList[i*self.__nsubplots]
693 693 zdB = avgdB[index].reshape((1,-1))
694 694 axes.pcolorbuffer(x, y, zdB,
695 695 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
696 696 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
697 697 ticksize=9, cblabel='', cbsize="1%", colormap=colormap)
698 698
699 699 if self.__showprofile:
700 700 axes = self.axesList[i*self.__nsubplots +1]
701 701 axes.pline(avgdB[index], y,
702 702 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
703 703 xlabel='dB', ylabel='', title='',
704 704 ytick_visible=False,
705 705 grid='x')
706 706
707 707 self.draw()
708 708
709 709 self.save(figpath=figpath,
710 710 figfile=figfile,
711 711 save=save,
712 712 ftp=ftp,
713 713 wr_period=wr_period,
714 714 thisDatetime=thisDatetime,
715 715 update_figfile=update_figfile)
716 716
717 717 class CoherenceMap(Figure):
718 718 isConfig = None
719 719 __nsubplots = None
720 720
721 721 WIDTHPROF = None
722 722 HEIGHTPROF = None
723 723 PREFIX = 'cmap'
724 724
725 725 def __init__(self, **kwargs):
726 726 Figure.__init__(self, **kwargs)
727 727 self.timerange = 2*60*60
728 728 self.isConfig = False
729 729 self.__nsubplots = 1
730 730
731 731 self.WIDTH = 800
732 732 self.HEIGHT = 180
733 733 self.WIDTHPROF = 120
734 734 self.HEIGHTPROF = 0
735 735 self.counter_imagwr = 0
736 736
737 737 self.PLOT_CODE = COH_CODE
738 738
739 739 self.FTP_WEI = None
740 740 self.EXP_CODE = None
741 741 self.SUB_EXP_CODE = None
742 742 self.PLOT_POS = None
743 743 self.counter_imagwr = 0
744 744
745 745 self.xmin = None
746 746 self.xmax = None
747 747
748 748 def getSubplots(self):
749 749 ncol = 1
750 750 nrow = self.nplots*2
751 751
752 752 return nrow, ncol
753 753
754 754 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
755 755 self.__showprofile = showprofile
756 756 self.nplots = nplots
757 757
758 758 ncolspan = 1
759 759 colspan = 1
760 760 if showprofile:
761 761 ncolspan = 7
762 762 colspan = 6
763 763 self.__nsubplots = 2
764 764
765 765 self.createFigure(id = id,
766 766 wintitle = wintitle,
767 767 widthplot = self.WIDTH + self.WIDTHPROF,
768 768 heightplot = self.HEIGHT + self.HEIGHTPROF,
769 769 show=True)
770 770
771 771 nrow, ncol = self.getSubplots()
772 772
773 773 for y in range(nrow):
774 774 for x in range(ncol):
775 775
776 776 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
777 777
778 778 if showprofile:
779 779 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
780 780
781 781 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
782 782 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
783 783 timerange=None, phase_min=None, phase_max=None,
784 784 save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
785 785 coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
786 786 server=None, folder=None, username=None, password=None,
787 787 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
788 788
789 789 if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
790 790 return
791 791
792 792 if pairsList == None:
793 793 pairsIndexList = dataOut.pairsIndexList
794 794 else:
795 795 pairsIndexList = []
796 796 for pair in pairsList:
797 797 if pair not in dataOut.pairsList:
798 798 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
799 799 pairsIndexList.append(dataOut.pairsList.index(pair))
800 800
801 801 if pairsIndexList == []:
802 802 return
803 803
804 804 if len(pairsIndexList) > 4:
805 805 pairsIndexList = pairsIndexList[0:4]
806 806
807 807 if phase_min == None:
808 808 phase_min = -180
809 809 if phase_max == None:
810 810 phase_max = 180
811 811
812 812 x = dataOut.getTimeRange()
813 813 y = dataOut.getHeiRange()
814 814
815 815 thisDatetime = dataOut.datatime
816 816
817 817 title = wintitle + " CoherenceMap" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
818 818 xlabel = ""
819 819 ylabel = "Range (Km)"
820 820 update_figfile = False
821 821
822 822 if not self.isConfig:
823 823 nplots = len(pairsIndexList)
824 824 self.setup(id=id,
825 825 nplots=nplots,
826 826 wintitle=wintitle,
827 827 showprofile=showprofile,
828 828 show=show)
829 829
830 830 if timerange != None:
831 831 self.timerange = timerange
832 832
833 833 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
834 834
835 835 if ymin == None: ymin = numpy.nanmin(y)
836 836 if ymax == None: ymax = numpy.nanmax(y)
837 837 if zmin == None: zmin = 0.
838 838 if zmax == None: zmax = 1.
839 839
840 840 self.FTP_WEI = ftp_wei
841 841 self.EXP_CODE = exp_code
842 842 self.SUB_EXP_CODE = sub_exp_code
843 843 self.PLOT_POS = plot_pos
844 844
845 845 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
846 846
847 847 self.isConfig = True
848 848 update_figfile = True
849 849
850 850 self.setWinTitle(title)
851 851
852 852 for i in range(self.nplots):
853 853
854 854 pair = dataOut.pairsList[pairsIndexList[i]]
855 855
856 856 ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
857 857 powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
858 858 powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
859 859
860 860
861 861 avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
862 862 coherence = numpy.abs(avgcoherenceComplex)
863 863
864 864 z = coherence.reshape((1,-1))
865 865
866 866 counter = 0
867 867
868 868 title = "Coherence Ch%d * Ch%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
869 869 axes = self.axesList[i*self.__nsubplots*2]
870 870 axes.pcolorbuffer(x, y, z,
871 871 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
872 872 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
873 873 ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
874 874
875 875 if self.__showprofile:
876 876 counter += 1
877 877 axes = self.axesList[i*self.__nsubplots*2 + counter]
878 878 axes.pline(coherence, y,
879 879 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
880 880 xlabel='', ylabel='', title='', ticksize=7,
881 881 ytick_visible=False, nxticks=5,
882 882 grid='x')
883 883
884 884 counter += 1
885 885
886 886 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
887 887
888 888 z = phase.reshape((1,-1))
889 889
890 890 title = "Phase Ch%d * Ch%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
891 891 axes = self.axesList[i*self.__nsubplots*2 + counter]
892 892 axes.pcolorbuffer(x, y, z,
893 893 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=phase_min, zmax=phase_max,
894 894 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
895 895 ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
896 896
897 897 if self.__showprofile:
898 898 counter += 1
899 899 axes = self.axesList[i*self.__nsubplots*2 + counter]
900 900 axes.pline(phase, y,
901 901 xmin=phase_min, xmax=phase_max, ymin=ymin, ymax=ymax,
902 902 xlabel='', ylabel='', title='', ticksize=7,
903 903 ytick_visible=False, nxticks=4,
904 904 grid='x')
905 905
906 906 self.draw()
907 907
908 908 if dataOut.ltctime >= self.xmax:
909 909 self.counter_imagwr = wr_period
910 910 self.isConfig = False
911 911 update_figfile = True
912 912
913 913 self.save(figpath=figpath,
914 914 figfile=figfile,
915 915 save=save,
916 916 ftp=ftp,
917 917 wr_period=wr_period,
918 918 thisDatetime=thisDatetime,
919 919 update_figfile=update_figfile)
920 920
921 921 class PowerProfilePlot(Figure):
922 922
923 923 isConfig = None
924 924 __nsubplots = None
925 925
926 926 WIDTHPROF = None
927 927 HEIGHTPROF = None
928 928 PREFIX = 'spcprofile'
929 929
930 930 def __init__(self, **kwargs):
931 931 Figure.__init__(self, **kwargs)
932 932 self.isConfig = False
933 933 self.__nsubplots = 1
934 934
935 935 self.PLOT_CODE = POWER_CODE
936 936
937 937 self.WIDTH = 300
938 938 self.HEIGHT = 500
939 939 self.counter_imagwr = 0
940 940
941 941 def getSubplots(self):
942 942 ncol = 1
943 943 nrow = 1
944 944
945 945 return nrow, ncol
946 946
947 947 def setup(self, id, nplots, wintitle, show):
948 948
949 949 self.nplots = nplots
950 950
951 951 ncolspan = 1
952 952 colspan = 1
953 953
954 954 self.createFigure(id = id,
955 955 wintitle = wintitle,
956 956 widthplot = self.WIDTH,
957 957 heightplot = self.HEIGHT,
958 958 show=show)
959 959
960 960 nrow, ncol = self.getSubplots()
961 961
962 962 counter = 0
963 963 for y in range(nrow):
964 964 for x in range(ncol):
965 965 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
966 966
967 967 def run(self, dataOut, id, wintitle="", channelList=None,
968 968 xmin=None, xmax=None, ymin=None, ymax=None,
969 969 save=False, figpath='./', figfile=None, show=True,
970 970 ftp=False, wr_period=1, server=None,
971 971 folder=None, username=None, password=None):
972 972
973 973
974 974 if channelList == None:
975 975 channelIndexList = dataOut.channelIndexList
976 976 channelList = dataOut.channelList
977 977 else:
978 978 channelIndexList = []
979 979 for channel in channelList:
980 980 if channel not in dataOut.channelList:
981 981 raise ValueError, "Channel %d is not in dataOut.channelList"
982 982 channelIndexList.append(dataOut.channelList.index(channel))
983 983
984 984 factor = dataOut.normFactor
985 985
986 986 y = dataOut.getHeiRange()
987 987
988 988 #for voltage
989 989 if dataOut.type == 'Voltage':
990 990 x = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
991 991 x = x.real
992 992 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
993 993
994 994 #for spectra
995 995 if dataOut.type == 'Spectra':
996 996 x = dataOut.data_spc[channelIndexList,:,:]/factor
997 997 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
998 998 x = numpy.average(x, axis=1)
999 999
1000 1000
1001 1001 xdB = 10*numpy.log10(x)
1002 1002
1003 1003 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
1004 1004 title = wintitle + " Power Profile %s" %(thisDatetime.strftime("%d-%b-%Y"))
1005 1005 xlabel = "dB"
1006 1006 ylabel = "Range (Km)"
1007 1007
1008 1008 if not self.isConfig:
1009 1009
1010 1010 nplots = 1
1011 1011
1012 1012 self.setup(id=id,
1013 1013 nplots=nplots,
1014 1014 wintitle=wintitle,
1015 1015 show=show)
1016 1016
1017 1017 if ymin == None: ymin = numpy.nanmin(y)
1018 1018 if ymax == None: ymax = numpy.nanmax(y)
1019 1019 if xmin == None: xmin = numpy.nanmin(xdB)*0.9
1020 1020 if xmax == None: xmax = numpy.nanmax(xdB)*1.1
1021 1021
1022 1022 self.isConfig = True
1023 1023
1024 1024 self.setWinTitle(title)
1025 1025
1026 1026 title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
1027 1027 axes = self.axesList[0]
1028 1028
1029 1029 legendlabels = ["channel %d"%x for x in channelList]
1030 1030 axes.pmultiline(xdB, y,
1031 1031 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
1032 1032 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
1033 1033 ytick_visible=True, nxticks=5,
1034 1034 grid='x')
1035 1035
1036 1036 self.draw()
1037 1037
1038 1038 self.save(figpath=figpath,
1039 1039 figfile=figfile,
1040 1040 save=save,
1041 1041 ftp=ftp,
1042 1042 wr_period=wr_period,
1043 1043 thisDatetime=thisDatetime)
1044 1044
1045 1045 class SpectraCutPlot(Figure):
1046 1046
1047 1047 isConfig = None
1048 1048 __nsubplots = None
1049 1049
1050 1050 WIDTHPROF = None
1051 1051 HEIGHTPROF = None
1052 1052 PREFIX = 'spc_cut'
1053 1053
1054 1054 def __init__(self, **kwargs):
1055 1055 Figure.__init__(self, **kwargs)
1056 1056 self.isConfig = False
1057 1057 self.__nsubplots = 1
1058 1058
1059 1059 self.PLOT_CODE = POWER_CODE
1060 1060
1061 1061 self.WIDTH = 700
1062 1062 self.HEIGHT = 500
1063 1063 self.counter_imagwr = 0
1064 1064
1065 1065 def getSubplots(self):
1066 1066 ncol = 1
1067 1067 nrow = 1
1068 1068
1069 1069 return nrow, ncol
1070 1070
1071 1071 def setup(self, id, nplots, wintitle, show):
1072 1072
1073 1073 self.nplots = nplots
1074 1074
1075 1075 ncolspan = 1
1076 1076 colspan = 1
1077 1077
1078 1078 self.createFigure(id = id,
1079 1079 wintitle = wintitle,
1080 1080 widthplot = self.WIDTH,
1081 1081 heightplot = self.HEIGHT,
1082 1082 show=show)
1083 1083
1084 1084 nrow, ncol = self.getSubplots()
1085 1085
1086 1086 counter = 0
1087 1087 for y in range(nrow):
1088 1088 for x in range(ncol):
1089 1089 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
1090 1090
1091 1091 def run(self, dataOut, id, wintitle="", channelList=None,
1092 1092 xmin=None, xmax=None, ymin=None, ymax=None,
1093 1093 save=False, figpath='./', figfile=None, show=True,
1094 1094 ftp=False, wr_period=1, server=None,
1095 1095 folder=None, username=None, password=None,
1096 1096 xaxis="frequency"):
1097 1097
1098 1098
1099 1099 if channelList == None:
1100 1100 channelIndexList = dataOut.channelIndexList
1101 1101 channelList = dataOut.channelList
1102 1102 else:
1103 1103 channelIndexList = []
1104 1104 for channel in channelList:
1105 1105 if channel not in dataOut.channelList:
1106 1106 raise ValueError, "Channel %d is not in dataOut.channelList"
1107 1107 channelIndexList.append(dataOut.channelList.index(channel))
1108 1108
1109 1109 factor = dataOut.normFactor
1110 1110
1111 1111 y = dataOut.getHeiRange()
1112 1112
1113 1113 z = dataOut.data_spc/factor
1114 1114 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
1115 1115
1116 1116 hei_index = numpy.arange(25)*3 + 20
1117 1117
1118 1118 if xaxis == "frequency":
1119 1119 x = dataOut.getFreqRange()/1000.
1120 1120 zdB = 10*numpy.log10(z[0,:,hei_index])
1121 1121 xlabel = "Frequency (kHz)"
1122 1122 ylabel = "Power (dB)"
1123 1123
1124 1124 elif xaxis == "time":
1125 1125 x = dataOut.getAcfRange()
1126 1126 zdB = z[0,:,hei_index]
1127 1127 xlabel = "Time (ms)"
1128 1128 ylabel = "ACF"
1129 1129
1130 1130 else:
1131 1131 x = dataOut.getVelRange()
1132 1132 zdB = 10*numpy.log10(z[0,:,hei_index])
1133 1133 xlabel = "Velocity (m/s)"
1134 1134 ylabel = "Power (dB)"
1135 1135
1136 1136 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
1137 1137 title = wintitle + " Range Cuts %s" %(thisDatetime.strftime("%d-%b-%Y"))
1138 1138
1139 1139 if not self.isConfig:
1140 1140
1141 1141 nplots = 1
1142 1142
1143 1143 self.setup(id=id,
1144 1144 nplots=nplots,
1145 1145 wintitle=wintitle,
1146 1146 show=show)
1147 1147
1148 1148 if xmin == None: xmin = numpy.nanmin(x)*0.9
1149 1149 if xmax == None: xmax = numpy.nanmax(x)*1.1
1150 1150 if ymin == None: ymin = numpy.nanmin(zdB)
1151 1151 if ymax == None: ymax = numpy.nanmax(zdB)
1152 1152
1153 1153 self.isConfig = True
1154 1154
1155 1155 self.setWinTitle(title)
1156 1156
1157 1157 title = "Spectra Cuts: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
1158 1158 axes = self.axesList[0]
1159 1159
1160 1160 legendlabels = ["Range = %dKm" %y[i] for i in hei_index]
1161 1161
1162 1162 axes.pmultilineyaxis( x, zdB,
1163 1163 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
1164 1164 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
1165 1165 ytick_visible=True, nxticks=5,
1166 1166 grid='x')
1167 1167
1168 1168 self.draw()
1169 1169
1170 1170 self.save(figpath=figpath,
1171 1171 figfile=figfile,
1172 1172 save=save,
1173 1173 ftp=ftp,
1174 1174 wr_period=wr_period,
1175 1175 thisDatetime=thisDatetime)
1176 1176
1177 1177 class Noise(Figure):
1178 1178
1179 1179 isConfig = None
1180 1180 __nsubplots = None
1181 1181
1182 1182 PREFIX = 'noise'
1183 1183
1184 1184
1185 1185 def __init__(self, **kwargs):
1186 1186 Figure.__init__(self, **kwargs)
1187 1187 self.timerange = 24*60*60
1188 1188 self.isConfig = False
1189 1189 self.__nsubplots = 1
1190 1190 self.counter_imagwr = 0
1191 1191 self.WIDTH = 800
1192 1192 self.HEIGHT = 400
1193 1193 self.WIDTHPROF = 120
1194 1194 self.HEIGHTPROF = 0
1195 1195 self.xdata = None
1196 1196 self.ydata = None
1197 1197
1198 1198 self.PLOT_CODE = NOISE_CODE
1199 1199
1200 1200 self.FTP_WEI = None
1201 1201 self.EXP_CODE = None
1202 1202 self.SUB_EXP_CODE = None
1203 1203 self.PLOT_POS = None
1204 1204 self.figfile = None
1205 1205
1206 1206 self.xmin = None
1207 1207 self.xmax = None
1208 1208
1209 1209 def getSubplots(self):
1210 1210
1211 1211 ncol = 1
1212 1212 nrow = 1
1213 1213
1214 1214 return nrow, ncol
1215 1215
1216 1216 def openfile(self, filename):
1217 1217 dirname = os.path.dirname(filename)
1218 1218
1219 1219 if not os.path.exists(dirname):
1220 1220 os.mkdir(dirname)
1221 1221
1222 1222 f = open(filename,'w+')
1223 1223 f.write('\n\n')
1224 1224 f.write('JICAMARCA RADIO OBSERVATORY - Noise \n')
1225 1225 f.write('DD MM YYYY HH MM SS Channel0 Channel1 Channel2 Channel3\n\n' )
1226 1226 f.close()
1227 1227
1228 1228 def save_data(self, filename_phase, data, data_datetime):
1229 1229
1230 1230 f=open(filename_phase,'a')
1231 1231
1232 1232 timetuple_data = data_datetime.timetuple()
1233 1233 day = str(timetuple_data.tm_mday)
1234 1234 month = str(timetuple_data.tm_mon)
1235 1235 year = str(timetuple_data.tm_year)
1236 1236 hour = str(timetuple_data.tm_hour)
1237 1237 minute = str(timetuple_data.tm_min)
1238 1238 second = str(timetuple_data.tm_sec)
1239 1239
1240 1240 data_msg = ''
1241 1241 for i in range(len(data)):
1242 1242 data_msg += str(data[i]) + ' '
1243 1243
1244 1244 f.write(day+' '+month+' '+year+' '+hour+' '+minute+' '+second+' ' + data_msg + '\n')
1245 1245 f.close()
1246 1246
1247 1247
1248 1248 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1249 1249
1250 1250 self.__showprofile = showprofile
1251 1251 self.nplots = nplots
1252 1252
1253 1253 ncolspan = 7
1254 1254 colspan = 6
1255 1255 self.__nsubplots = 2
1256 1256
1257 1257 self.createFigure(id = id,
1258 1258 wintitle = wintitle,
1259 1259 widthplot = self.WIDTH+self.WIDTHPROF,
1260 1260 heightplot = self.HEIGHT+self.HEIGHTPROF,
1261 1261 show=show)
1262 1262
1263 1263 nrow, ncol = self.getSubplots()
1264 1264
1265 1265 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1266 1266
1267 1267
1268 1268 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
1269 1269 xmin=None, xmax=None, ymin=None, ymax=None,
1270 1270 timerange=None,
1271 1271 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
1272 1272 server=None, folder=None, username=None, password=None,
1273 1273 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1274 1274
1275 1275 if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
1276 1276 return
1277 1277
1278 1278 if channelList == None:
1279 1279 channelIndexList = dataOut.channelIndexList
1280 1280 channelList = dataOut.channelList
1281 1281 else:
1282 1282 channelIndexList = []
1283 1283 for channel in channelList:
1284 1284 if channel not in dataOut.channelList:
1285 1285 raise ValueError, "Channel %d is not in dataOut.channelList"
1286 1286 channelIndexList.append(dataOut.channelList.index(channel))
1287 1287
1288 1288 x = dataOut.getTimeRange()
1289 1289 #y = dataOut.getHeiRange()
1290 1290 factor = dataOut.normFactor
1291 1291 noise = dataOut.noise[channelIndexList]/factor
1292 1292 noisedB = 10*numpy.log10(noise)
1293 1293
1294 1294 thisDatetime = dataOut.datatime
1295 1295
1296 1296 title = wintitle + " Noise" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
1297 1297 xlabel = ""
1298 1298 ylabel = "Intensity (dB)"
1299 1299 update_figfile = False
1300 1300
1301 1301 if not self.isConfig:
1302 1302
1303 1303 nplots = 1
1304 1304
1305 1305 self.setup(id=id,
1306 1306 nplots=nplots,
1307 1307 wintitle=wintitle,
1308 1308 showprofile=showprofile,
1309 1309 show=show)
1310 1310
1311 1311 if timerange != None:
1312 1312 self.timerange = timerange
1313 1313
1314 1314 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
1315 1315
1316 1316 if ymin == None: ymin = numpy.floor(numpy.nanmin(noisedB)) - 10.0
1317 1317 if ymax == None: ymax = numpy.nanmax(noisedB) + 10.0
1318 1318
1319 1319 self.FTP_WEI = ftp_wei
1320 1320 self.EXP_CODE = exp_code
1321 1321 self.SUB_EXP_CODE = sub_exp_code
1322 1322 self.PLOT_POS = plot_pos
1323 1323
1324 1324
1325 1325 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1326 1326 self.isConfig = True
1327 1327 self.figfile = figfile
1328 1328 self.xdata = numpy.array([])
1329 1329 self.ydata = numpy.array([])
1330 1330
1331 1331 update_figfile = True
1332 1332
1333 1333 #open file beacon phase
1334 1334 path = '%s%03d' %(self.PREFIX, self.id)
1335 1335 noise_file = os.path.join(path,'%s.txt'%self.name)
1336 1336 self.filename_noise = os.path.join(figpath,noise_file)
1337 1337
1338 1338 self.setWinTitle(title)
1339 1339
1340 1340 title = "Noise %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1341 1341
1342 1342 legendlabels = ["channel %d"%(idchannel) for idchannel in channelList]
1343 1343 axes = self.axesList[0]
1344 1344
1345 1345 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1346 1346
1347 1347 if len(self.ydata)==0:
1348 1348 self.ydata = noisedB.reshape(-1,1)
1349 1349 else:
1350 1350 self.ydata = numpy.hstack((self.ydata, noisedB.reshape(-1,1)))
1351 1351
1352 1352
1353 1353 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1354 1354 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
1355 1355 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1356 1356 XAxisAsTime=True, grid='both'
1357 1357 )
1358 1358
1359 1359 self.draw()
1360 1360
1361 1361 if dataOut.ltctime >= self.xmax:
1362 1362 self.counter_imagwr = wr_period
1363 1363 self.isConfig = False
1364 1364 update_figfile = True
1365 1365
1366 1366 self.save(figpath=figpath,
1367 1367 figfile=figfile,
1368 1368 save=save,
1369 1369 ftp=ftp,
1370 1370 wr_period=wr_period,
1371 1371 thisDatetime=thisDatetime,
1372 1372 update_figfile=update_figfile)
1373 1373
1374 1374 #store data beacon phase
1375 1375 if save:
1376 1376 self.save_data(self.filename_noise, noisedB, thisDatetime)
1377 1377
1378 1378 class BeaconPhase(Figure):
1379 1379
1380 1380 __isConfig = None
1381 1381 __nsubplots = None
1382 1382
1383 1383 PREFIX = 'beacon_phase'
1384 1384
1385 1385 def __init__(self, **kwargs):
1386 1386 Figure.__init__(self, **kwargs)
1387 1387 self.timerange = 24*60*60
1388 1388 self.isConfig = False
1389 1389 self.__nsubplots = 1
1390 1390 self.counter_imagwr = 0
1391 1391 self.WIDTH = 800
1392 1392 self.HEIGHT = 400
1393 1393 self.WIDTHPROF = 120
1394 1394 self.HEIGHTPROF = 0
1395 1395 self.xdata = None
1396 1396 self.ydata = None
1397 1397
1398 1398 self.PLOT_CODE = BEACON_CODE
1399 1399
1400 1400 self.FTP_WEI = None
1401 1401 self.EXP_CODE = None
1402 1402 self.SUB_EXP_CODE = None
1403 1403 self.PLOT_POS = None
1404 1404
1405 1405 self.filename_phase = None
1406 1406
1407 1407 self.figfile = None
1408 1408
1409 1409 self.xmin = None
1410 1410 self.xmax = None
1411 1411
1412 1412 def getSubplots(self):
1413 1413
1414 1414 ncol = 1
1415 1415 nrow = 1
1416 1416
1417 1417 return nrow, ncol
1418 1418
1419 1419 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1420 1420
1421 1421 self.__showprofile = showprofile
1422 1422 self.nplots = nplots
1423 1423
1424 1424 ncolspan = 7
1425 1425 colspan = 6
1426 1426 self.__nsubplots = 2
1427 1427
1428 1428 self.createFigure(id = id,
1429 1429 wintitle = wintitle,
1430 1430 widthplot = self.WIDTH+self.WIDTHPROF,
1431 1431 heightplot = self.HEIGHT+self.HEIGHTPROF,
1432 1432 show=show)
1433 1433
1434 1434 nrow, ncol = self.getSubplots()
1435 1435
1436 1436 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1437 1437
1438 1438 def save_phase(self, filename_phase):
1439 1439 f = open(filename_phase,'w+')
1440 1440 f.write('\n\n')
1441 1441 f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
1442 1442 f.write('DD MM YYYY HH MM SS pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
1443 1443 f.close()
1444 1444
1445 1445 def save_data(self, filename_phase, data, data_datetime):
1446 1446 f=open(filename_phase,'a')
1447 1447 timetuple_data = data_datetime.timetuple()
1448 1448 day = str(timetuple_data.tm_mday)
1449 1449 month = str(timetuple_data.tm_mon)
1450 1450 year = str(timetuple_data.tm_year)
1451 1451 hour = str(timetuple_data.tm_hour)
1452 1452 minute = str(timetuple_data.tm_min)
1453 1453 second = str(timetuple_data.tm_sec)
1454 1454 f.write(day+' '+month+' '+year+' '+hour+' '+minute+' '+second+' '+str(data[0])+' '+str(data[1])+' '+str(data[2])+' '+str(data[3])+'\n')
1455 1455 f.close()
1456 1456
1457 1457
1458 1458 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
1459 1459 xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
1460 1460 timerange=None,
1461 1461 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
1462 1462 server=None, folder=None, username=None, password=None,
1463 1463 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1464 1464
1465 1465 if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
1466 1466 return
1467 1467
1468 1468 if pairsList == None:
1469 1469 pairsIndexList = dataOut.pairsIndexList[:10]
1470 1470 else:
1471 1471 pairsIndexList = []
1472 1472 for pair in pairsList:
1473 1473 if pair not in dataOut.pairsList:
1474 1474 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
1475 1475 pairsIndexList.append(dataOut.pairsList.index(pair))
1476 1476
1477 1477 if pairsIndexList == []:
1478 1478 return
1479 1479
1480 1480 # if len(pairsIndexList) > 4:
1481 1481 # pairsIndexList = pairsIndexList[0:4]
1482 1482
1483 1483 hmin_index = None
1484 1484 hmax_index = None
1485 1485
1486 1486 if hmin != None and hmax != None:
1487 1487 indexes = numpy.arange(dataOut.nHeights)
1488 1488 hmin_list = indexes[dataOut.heightList >= hmin]
1489 1489 hmax_list = indexes[dataOut.heightList <= hmax]
1490 1490
1491 1491 if hmin_list.any():
1492 1492 hmin_index = hmin_list[0]
1493 1493
1494 1494 if hmax_list.any():
1495 1495 hmax_index = hmax_list[-1]+1
1496 1496
1497 1497 x = dataOut.getTimeRange()
1498 1498 #y = dataOut.getHeiRange()
1499 1499
1500 1500
1501 1501 thisDatetime = dataOut.datatime
1502 1502
1503 1503 title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
1504 1504 xlabel = "Local Time"
1505 1505 ylabel = "Phase (degrees)"
1506 1506
1507 1507 update_figfile = False
1508 1508
1509 1509 nplots = len(pairsIndexList)
1510 1510 #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
1511 1511 phase_beacon = numpy.zeros(len(pairsIndexList))
1512 1512 for i in range(nplots):
1513 1513 pair = dataOut.pairsList[pairsIndexList[i]]
1514 1514 ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
1515 1515 powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
1516 1516 powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
1517 1517 avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
1518 1518 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
1519 1519
1520 1520 #print "Phase %d%d" %(pair[0], pair[1])
1521 1521 #print phase[dataOut.beacon_heiIndexList]
1522 1522
1523 1523 if dataOut.beacon_heiIndexList:
1524 1524 phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
1525 1525 else:
1526 1526 phase_beacon[i] = numpy.average(phase)
1527 1527
1528 1528 if not self.isConfig:
1529 1529
1530 1530 nplots = len(pairsIndexList)
1531 1531
1532 1532 self.setup(id=id,
1533 1533 nplots=nplots,
1534 1534 wintitle=wintitle,
1535 1535 showprofile=showprofile,
1536 1536 show=show)
1537 1537
1538 1538 if timerange != None:
1539 1539 self.timerange = timerange
1540 1540
1541 1541 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
1542 1542
1543 1543 if ymin == None: ymin = 0
1544 1544 if ymax == None: ymax = 360
1545 1545
1546 1546 self.FTP_WEI = ftp_wei
1547 1547 self.EXP_CODE = exp_code
1548 1548 self.SUB_EXP_CODE = sub_exp_code
1549 1549 self.PLOT_POS = plot_pos
1550 1550
1551 1551 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1552 1552 self.isConfig = True
1553 1553 self.figfile = figfile
1554 1554 self.xdata = numpy.array([])
1555 1555 self.ydata = numpy.array([])
1556 1556
1557 1557 update_figfile = True
1558 1558
1559 1559 #open file beacon phase
1560 1560 path = '%s%03d' %(self.PREFIX, self.id)
1561 1561 beacon_file = os.path.join(path,'%s.txt'%self.name)
1562 1562 self.filename_phase = os.path.join(figpath,beacon_file)
1563 1563 #self.save_phase(self.filename_phase)
1564 1564
1565 1565
1566 1566 #store data beacon phase
1567 1567 #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
1568 1568
1569 1569 self.setWinTitle(title)
1570 1570
1571 1571
1572 1572 title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1573 1573
1574 1574 legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
1575 1575
1576 1576 axes = self.axesList[0]
1577 1577
1578 1578 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1579 1579
1580 1580 if len(self.ydata)==0:
1581 1581 self.ydata = phase_beacon.reshape(-1,1)
1582 1582 else:
1583 1583 self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
1584 1584
1585 1585
1586 1586 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1587 1587 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
1588 1588 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1589 1589 XAxisAsTime=True, grid='both'
1590 1590 )
1591 1591
1592 1592 self.draw()
1593 1593
1594 1594 if dataOut.ltctime >= self.xmax:
1595 1595 self.counter_imagwr = wr_period
1596 1596 self.isConfig = False
1597 1597 update_figfile = True
1598 1598
1599 1599 self.save(figpath=figpath,
1600 1600 figfile=figfile,
1601 1601 save=save,
1602 1602 ftp=ftp,
1603 1603 wr_period=wr_period,
1604 1604 thisDatetime=thisDatetime,
1605 1605 update_figfile=update_figfile)
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,1 +1,1
1 <Project description="Segundo Test" id="191" name="test01"><ReadUnit datatype="SpectraReader" id="1911" inputId="0" name="SpectraReader"><Operation id="19111" name="run" priority="1" type="self"><Parameter format="str" id="191111" name="datatype" value="SpectraReader" /><Parameter format="str" id="191112" name="path" value="/media/erick/6F60F7113095A154/CLAIRE/CLAIRE_WINDS_2MHZ/DATA/pdataCLAIRE/Extra" /><Parameter format="date" id="191113" name="startDate" value="2018/02/01" /><Parameter format="date" id="191114" name="endDate" value="2018/02/01" /><Parameter format="time" id="191115" name="startTime" value="17:00:00" /><Parameter format="time" id="191116" name="endTime" value="20:00:00" /><Parameter format="int" id="191118" name="online" value="0" /><Parameter format="int" id="191119" name="walk" value="1" /></Operation><Operation id="19112" name="printInfo" priority="2" type="self" /><Operation id="19113" name="printNumberOfBlock" priority="3" type="self" /></ReadUnit><ProcUnit datatype="Parameters" id="1913" inputId="1912" name="ParametersProc"><Operation id="19131" name="run" priority="1" type="self" /><Operation id="19132" name="SpectralFilters" priority="2" type="other"><Parameter format="float" id="191321" name="Wind_Velocity_Limit" value="2.5" /><Parameter format="float" id="191322" name="Rain_Velocity_Limit" value="1.5" /></Operation><Operation id="19133" name="FullSpectralAnalysis" priority="3" type="other"><Parameter format="float" id="191331" name="SNRlimit" value="-16" /><Parameter format="float" id="191332" name="E01" value="1.500" /><Parameter format="float" id="191333" name="E02" value="1.500" /><Parameter format="float" id="191334" name="E12" value="0" /><Parameter format="float" id="191335" name="N01" value="0.875" /><Parameter format="float" id="191336" name="N02" value="-0.875" /><Parameter format="float" id="191337" name="N12" value="-1.750" /></Operation><Operation id="19134" name="WindProfilerPlot" priority="4" type="other"><Parameter format="int" id="191341" name="id" value="4" /><Parameter format="str" id="191342" name="wintitle" value="Wind Profiler" /><Parameter format="float" id="191343" name="xmin" value="17" /><Parameter format="float" id="191344" name="xmax" value="20" /><Parameter format="float" id="191345" name="ymin" value="0" /><Parameter format="int" id="191346" name="ymax" value="8" /><Parameter format="float" id="191347" name="zmin" value="-20" /><Parameter format="float" id="191348" name="zmax" value="20" /><Parameter format="float" id="191349" name="SNRmin" value="-20" /><Parameter format="float" id="191350" name="SNRmax" value="20" /><Parameter format="float" id="191351" name="zmin_ver" value="-200" /><Parameter format="float" id="191352" name="zmax_ver" value="200" /><Parameter format="float" id="191353" name="SNRthresh" value="-20" /><Parameter format="int" id="191354" name="save" value="1" /><Parameter format="str" id="191355" name="figpath" value="/media/erick/6F60F7113095A154/CLAIRE/CLAIRE_WINDS_2MHZ/DATA/pdataCLAIRE/Extra" /></Operation><Operation id="19135" name="PrecipitationProc" priority="5" type="other" /><Operation id="19136" name="ParametersPlot" priority="6" type="other"><Parameter format="int" id="191361" name="id" value="10" /><Parameter format="str" id="191362" name="wintitle" value="First_gg" /><Parameter format="int" id="191363" name="zmin" value="-20" /><Parameter format="int" id="191364" name="zmax" value="60" /><Parameter format="int" id="191365" name="ymin" value="0" /><Parameter format="int" id="191366" name="ymax" value="8" /><Parameter format="int" id="191367" name="xmin" value="17" /><Parameter format="int" id="191368" name="xmax" value="20" /><Parameter format="int" id="191369" name="save" value="1" /><Parameter format="str" id="191370" name="figpath" value="/media/erick/6F60F7113095A154/CLAIRE/CLAIRE_WINDS_2MHZ/DATA/pdataCLAIRE/Extra" /></Operation><Operation id="19137" name="ParamWriter" priority="7" type="other"><Parameter format="str" id="191371" name="path" value="/media/erick/6F60F7113095A154/CLAIRE/CLAIRE_WINDS_2MHZ/DATA/pdatatest/test1024" /><Parameter format="int" id="191372" name="blocksPerFile" value="100" /><Parameter format="list" id="191373" name="metadataList" value="heightList,timeZone,paramInterval" /><Parameter format="list" id="191374" name="dataList" value="data_output,data_SNR,utctime,utctimeInit" /></Operation></ProcUnit><ProcUnit datatype="SpectraProc" id="1912" inputId="1911" name="SpectraProc"><Operation id="19121" name="run" priority="1" type="self" /><Operation id="19122" name="setRadarFrequency" priority="2" type="self"><Parameter format="float" id="191221" name="frequency" value="445.09e6" /></Operation></ProcUnit></Project> No newline at end of file
1 <Project description="Segundo Test" id="191" name="test01"><ReadUnit datatype="SpectraReader" id="1911" inputId="0" name="SpectraReader"><Operation id="19111" name="run" priority="1" type="self"><Parameter format="str" id="191111" name="datatype" value="SpectraReader" /><Parameter format="str" id="191112" name="path" value="/media/erick/6F60F7113095A154/CLAIRE/CLAIRE_WINDS_2MHZ/DATA/pdataCLAIRE/Extra" /><Parameter format="date" id="191113" name="startDate" value="2018/02/01" /><Parameter format="date" id="191114" name="endDate" value="2018/02/01" /><Parameter format="time" id="191115" name="startTime" value="17:00:00" /><Parameter format="time" id="191116" name="endTime" value="20:00:00" /><Parameter format="int" id="191118" name="online" value="0" /><Parameter format="int" id="191119" name="walk" value="1" /></Operation><Operation id="19112" name="printInfo" priority="2" type="self" /><Operation id="19113" name="printNumberOfBlock" priority="3" type="self" /></ReadUnit><ProcUnit datatype="Parameters" id="1913" inputId="1912" name="ParametersProc"><Operation id="19131" name="run" priority="1" type="self" /><Operation id="19132" name="SpectralFilters" priority="2" type="other"><Parameter format="float" id="191321" name="PositiveLimit" value="1.5" /><Parameter format="float" id="191322" name="NegativeLimit" value="3.5" /></Operation><Operation id="19133" name="FullSpectralAnalysis" priority="3" type="other"><Parameter format="float" id="191331" name="SNRlimit" value="-16" /><Parameter format="float" id="191332" name="E01" value="1.500" /><Parameter format="float" id="191333" name="E02" value="1.500" /><Parameter format="float" id="191334" name="E12" value="0" /><Parameter format="float" id="191335" name="N01" value="0.875" /><Parameter format="float" id="191336" name="N02" value="-0.875" /><Parameter format="float" id="191337" name="N12" value="-1.750" /></Operation><Operation id="19134" name="WindProfilerPlot" priority="4" type="other"><Parameter format="int" id="191341" name="id" value="4" /><Parameter format="str" id="191342" name="wintitle" value="Wind Profiler" /><Parameter format="float" id="191343" name="xmin" value="17" /><Parameter format="float" id="191344" name="xmax" value="20" /><Parameter format="float" id="191345" name="ymin" value="0" /><Parameter format="int" id="191346" name="ymax" value="11" /><Parameter format="float" id="191347" name="zmin" value="-20" /><Parameter format="float" id="191348" name="zmax" value="20" /><Parameter format="float" id="191349" name="SNRmin" value="-20" /><Parameter format="float" id="191350" name="SNRmax" value="20" /><Parameter format="float" id="191351" name="zmin_ver" value="-200" /><Parameter format="float" id="191352" name="zmax_ver" value="200" /><Parameter format="float" id="191353" name="SNRthresh" value="-20" /><Parameter format="int" id="191354" name="save" value="1" /><Parameter format="str" id="191355" name="figpath" value="/media/erick/6F60F7113095A154/CLAIRE/CLAIRE_WINDS_2MHZ/DATA/pdataCLAIRE/Extra" /></Operation><Operation id="19135" name="PrecipitationProc" priority="5" type="other" /><Operation id="19136" name="ParametersPlot" priority="6" type="other"><Parameter format="int" id="191361" name="id" value="10" /><Parameter format="str" id="191362" name="wintitle" value="First_gg" /><Parameter format="str" id="191363" name="colormap" value="ocean_r" /><Parameter format="int" id="191364" name="zmin" value="50" /><Parameter format="int" id="191365" name="zmax" value="100" /><Parameter format="int" id="191366" name="ymin" value="0" /><Parameter format="int" id="191367" name="ymax" value="11" /><Parameter format="int" id="191368" name="xmin" value="17" /><Parameter format="int" id="191369" name="xmax" value="20" /><Parameter format="int" id="191370" name="save" value="1" /><Parameter format="str" id="191371" name="figpath" value="/media/erick/6F60F7113095A154/CLAIRE/CLAIRE_WINDS_2MHZ/DATA/pdataCLAIRE/Extra" /></Operation><Operation id="19137" name="SpcParamPlot" priority="7" type="other"><Parameter format="int" id="191371" name="id" value="21" /><Parameter format="str" id="191372" name="wintitle" value="Primer eco removido" /><Parameter format="str" id="191373" name="xaxis" value="velocity" /><Parameter format="int" id="191374" name="showprofile" value="1" /><Parameter format="int" id="191375" name="zmin" value="10" /><Parameter format="int" id="191376" name="zmax" value="40" /><Parameter format="int" id="191377" name="Selector" value="1" /></Operation><Operation id="19138" name="ParamWriter" priority="8" type="other"><Parameter format="str" id="191381" name="path" value="/media/erick/6F60F7113095A154/CLAIRE/CLAIRE_WINDS_2MHZ/DATA/pdatatest/test1024" /><Parameter format="int" id="191382" name="blocksPerFile" value="100" /><Parameter format="list" id="191383" name="metadataList" value="heightList,timeZone,paramInterval" /><Parameter format="list" id="191384" name="dataList" value="data_output,data_SNR,utctime,utctimeInit" /></Operation></ProcUnit><ProcUnit datatype="SpectraProc" id="1912" inputId="1911" name="SpectraProc"><Operation id="19121" name="run" priority="1" type="self" /><Operation id="19122" name="setRadarFrequency" priority="2" type="self"><Parameter format="float" id="191221" name="frequency" value="445.09e6" /></Operation></ProcUnit></Project> No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now