##// END OF EJS Templates
schain
RSS
Timezone is taken from data and not from PC
Miguel Valdez -
r565:9a975da57daf
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,607 +1,607
1 1 import os
2 2 import numpy
3 3 import time, datetime
4 4 import mpldriver
5 5
6 6
7 7 import Queue
8 8 import threading
9 9
10 10 def isRealtime(utcdatatime):
11 11 utcnow = time.mktime(time.localtime())
12 12 delta = abs(utcnow - utcdatatime) # abs
13 13 if delta >= 30.:
14 14 return False
15 15 return True
16 16
17 17
18 18
19 19
20 20 class Figure:
21 21
22 22 __driver = mpldriver
23 23 __isConfigThread = False
24 24 fig = None
25 25
26 26 id = None
27 27 wintitle = None
28 28 width = None
29 29 height = None
30 30 nplots = None
31 31 timerange = None
32 32
33 33 axesObjList = []
34 34
35 35 WIDTH = None
36 36 HEIGHT = None
37 37 PREFIX = 'fig'
38 38
39 39 xmin = None
40 40 xmax = None
41 41
42 42 def __init__(self):
43 43
44 44 raise ValueError, "This method is not implemented"
45 45
46 46 def __del__(self):
47 47
48 48 self.__driver.closeFigure()
49 49
50 50 def getFilename(self, name, ext='.png'):
51 51
52 52 path = '%s%03d' %(self.PREFIX, self.id)
53 53 filename = '%s_%s%s' %(self.PREFIX, name, ext)
54 54 return os.path.join(path, filename)
55 55
56 56 def getAxesObjList(self):
57 57
58 58 return self.axesObjList
59 59
60 60 def getSubplots(self):
61 61
62 62 raise ValueError, "Abstract method: This method should be defined"
63 63
64 64 def getScreenDim(self, widthplot, heightplot):
65 65
66 66 nrow, ncol = self.getSubplots()
67 67
68 68 widthscreen = widthplot*ncol
69 69 heightscreen = heightplot*nrow
70 70
71 71 return widthscreen, heightscreen
72 72
73 def getTimeLim(self, x, xmin=None, xmax=None, timerange=None):
73 def getTimeLim(self, x, xmin=None, xmax=None, timerange=None, timezone=0):
74 74
75 75 if self.xmin != None and self.xmax != None:
76 76 if timerange == None:
77 77 timerange = self.xmax - self.xmin
78 78 xmin = self.xmin + timerange
79 79 xmax = self.xmax + timerange
80 80
81 81 return xmin, xmax
82 82
83 83
84 84 if timerange != None and self.xmin == None and self.xmax == None:
85 85 txmin = x[0] - x[0]%timerange
86 86 else:
87 87 txmin = numpy.min(x)
88 88 timerange = self.timerange
89 89 thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
90 90 thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
91 91 if xmin == None and xmax == None:
92 92 xmin = (thisdatetime - thisdate).seconds/(60*60.)
93 93 xmax = xmin + timerange/(60*60.)
94 94
95 95
96 96
97 mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
97 mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=timezone)
98 98 xmin_sec = time.mktime(mindt.timetuple())
99 99
100 maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
100 maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=timezone)
101 101 xmax_sec = time.mktime(maxdt.timetuple())
102 102
103 103 return xmin_sec, xmax_sec
104 104
105 105
106 106
107 107
108 108
109 109 # if timerange != None:
110 110 # txmin = x[0] - x[0]%timerange
111 111 # else:
112 112 # txmin = numpy.min(x)
113 113 #
114 114 # thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
115 115 # thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
116 116 #
117 117 # ####################################################
118 118 # #If the x is out of xrange
119 119 # if xmax != None:
120 120 # if xmax < (thisdatetime - thisdate).seconds/(60*60.):
121 121 # xmin = None
122 122 # xmax = None
123 123 #
124 124 # if xmin == None:
125 125 # td = thisdatetime - thisdate
126 126 # xmin = td.seconds/(60*60.)
127 127 #
128 128 # if xmax == None:
129 129 # xmax = xmin + self.timerange/(60*60.)
130 130 #
131 131 # mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
132 132 # tmin = time.mktime(mindt.timetuple())
133 133 #
134 134 # maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
135 135 # tmax = time.mktime(maxdt.timetuple())
136 136 #
137 137 # #self.timerange = tmax - tmin
138 138 #
139 139 # return tmin, tmax
140 140
141 141 def init(self, id, nplots, wintitle):
142 142
143 143 raise ValueError, "This method has been replaced with createFigure"
144 144
145 145 def createFigure(self, id, wintitle, widthplot=None, heightplot=None, show=True):
146 146
147 147 """
148 148 Crea la figura de acuerdo al driver y parametros seleccionados seleccionados.
149 149 Las dimensiones de la pantalla es calculada a partir de los atributos self.WIDTH
150 150 y self.HEIGHT y el numero de subplots (nrow, ncol)
151 151
152 152 Input:
153 153 id : Los parametros necesarios son
154 154 wintitle :
155 155
156 156 """
157 157
158 158 if widthplot == None:
159 159 widthplot = self.WIDTH
160 160
161 161 if heightplot == None:
162 162 heightplot = self.HEIGHT
163 163
164 164 self.id = id
165 165
166 166 self.wintitle = wintitle
167 167
168 168 self.widthscreen, self.heightscreen = self.getScreenDim(widthplot, heightplot)
169 169
170 170 self.fig = self.__driver.createFigure(id=self.id,
171 171 wintitle=self.wintitle,
172 172 width=self.widthscreen,
173 173 height=self.heightscreen,
174 174 show=show)
175 175
176 176 self.axesObjList = []
177 177
178 178
179 179 def setDriver(self, driver=mpldriver):
180 180
181 181 self.__driver = driver
182 182
183 183 def setTitle(self, title):
184 184
185 185 self.__driver.setTitle(self.fig, title)
186 186
187 187 def setWinTitle(self, title):
188 188
189 189 self.__driver.setWinTitle(self.fig, title=title)
190 190
191 191 def setTextFromAxes(self, text):
192 192
193 193 raise ValueError, "Este metodo ha sido reemplazaado con el metodo setText de la clase Axes"
194 194
195 195 def makeAxes(self, nrow, ncol, xpos, ypos, colspan, rowspan):
196 196
197 197 raise ValueError, "Este metodo ha sido reemplazaado con el metodo addAxes"
198 198
199 199 def addAxes(self, *args):
200 200 """
201 201
202 202 Input:
203 203 *args : Los parametros necesarios son
204 204 nrow, ncol, xpos, ypos, colspan, rowspan
205 205 """
206 206
207 207 axesObj = Axes(self.fig, *args)
208 208 self.axesObjList.append(axesObj)
209 209
210 210 def saveFigure(self, figpath, figfile, *args):
211 211
212 212 filename = os.path.join(figpath, figfile)
213 213
214 214 fullpath = os.path.split(filename)[0]
215 215
216 216 if not os.path.exists(fullpath):
217 217 subpath = os.path.split(fullpath)[0]
218 218
219 219 if not os.path.exists(subpath):
220 220 os.mkdir(subpath)
221 221
222 222 os.mkdir(fullpath)
223 223
224 224 self.__driver.saveFigure(self.fig, filename, *args)
225 225
226 226
227 227
228 228
229 229 def getNameToFtp(self, thisDatetime, FTP_WEI, EXP_CODE, SUB_EXP_CODE, PLOT_CODE, PLOT_POS):
230 230 YEAR_STR = '%4.4d'%thisDatetime.timetuple().tm_year
231 231 DOY_STR = '%3.3d'%thisDatetime.timetuple().tm_yday
232 232 FTP_WEI = '%2.2d'%FTP_WEI
233 233 EXP_CODE = '%3.3d'%EXP_CODE
234 234 SUB_EXP_CODE = '%2.2d'%SUB_EXP_CODE
235 235 PLOT_CODE = '%2.2d'%PLOT_CODE
236 236 PLOT_POS = '%2.2d'%PLOT_POS
237 237 name = YEAR_STR + DOY_STR + FTP_WEI + EXP_CODE + SUB_EXP_CODE + PLOT_CODE + PLOT_POS
238 238 return name
239 239
240 240 def draw(self):
241 241
242 242 self.__driver.draw(self.fig)
243 243
244 244 def run(self):
245 245
246 246 raise ValueError, "This method is not implemented"
247 247
248 248 def close(self):
249 249
250 250 self.__driver.show(True)
251 251
252 252 axesList = property(getAxesObjList)
253 253
254 254
255 255 class Axes:
256 256
257 257 __driver = mpldriver
258 258 fig = None
259 259 ax = None
260 260 plot = None
261 261 __missing = 1E30
262 262 __firsttime = None
263 263
264 264 __showprofile = False
265 265
266 266 xmin = None
267 267 xmax = None
268 268 ymin = None
269 269 ymax = None
270 270 zmin = None
271 271 zmax = None
272 272
273 273 x_buffer = None
274 274 z_buffer = None
275 275
276 276 decimationx = None
277 277 decimationy = None
278 278
279 279 __MAXNUMX = 300
280 280 __MAXNUMY = 150
281 281
282 282 def __init__(self, *args):
283 283
284 284 """
285 285
286 286 Input:
287 287 *args : Los parametros necesarios son
288 288 fig, nrow, ncol, xpos, ypos, colspan, rowspan
289 289 """
290 290
291 291 ax = self.__driver.createAxes(*args)
292 292 self.fig = args[0]
293 293 self.ax = ax
294 294 self.plot = None
295 295
296 296 self.__firsttime = True
297 297 self.idlineList = []
298 298
299 299 self.x_buffer = numpy.array([])
300 300 self.z_buffer = numpy.array([])
301 301
302 302 def setText(self, text):
303 303
304 304 self.__driver.setAxesText(self.ax, text)
305 305
306 306 def setXAxisAsTime(self):
307 307 pass
308 308
309 309 def pline(self, x, y,
310 310 xmin=None, xmax=None,
311 311 ymin=None, ymax=None,
312 312 xlabel='', ylabel='',
313 313 title='',
314 314 **kwargs):
315 315
316 316 """
317 317
318 318 Input:
319 319 x :
320 320 y :
321 321 xmin :
322 322 xmax :
323 323 ymin :
324 324 ymax :
325 325 xlabel :
326 326 ylabel :
327 327 title :
328 328 **kwargs : Los parametros aceptados son
329 329
330 330 ticksize
331 331 ytick_visible
332 332 """
333 333
334 334 if self.__firsttime:
335 335
336 336 if xmin == None: xmin = numpy.nanmin(x)
337 337 if xmax == None: xmax = numpy.nanmax(x)
338 338 if ymin == None: ymin = numpy.nanmin(y)
339 339 if ymax == None: ymax = numpy.nanmax(y)
340 340
341 341 self.plot = self.__driver.createPline(self.ax, x, y,
342 342 xmin, xmax,
343 343 ymin, ymax,
344 344 xlabel=xlabel,
345 345 ylabel=ylabel,
346 346 title=title,
347 347 **kwargs)
348 348
349 349 self.idlineList.append(0)
350 350 self.__firsttime = False
351 351 return
352 352
353 353 self.__driver.pline(self.plot, x, y, xlabel=xlabel,
354 354 ylabel=ylabel,
355 355 title=title)
356 356
357 357 def addpline(self, x, y, idline, **kwargs):
358 358 lines = self.ax.lines
359 359
360 360 if idline in self.idlineList:
361 361 self.__driver.set_linedata(self.ax, x, y, idline)
362 362
363 363 if idline not in(self.idlineList):
364 364 self.__driver.addpline(self.ax, x, y, **kwargs)
365 365 self.idlineList.append(idline)
366 366
367 367 return
368 368
369 369 def pmultiline(self, x, y,
370 370 xmin=None, xmax=None,
371 371 ymin=None, ymax=None,
372 372 xlabel='', ylabel='',
373 373 title='',
374 374 **kwargs):
375 375
376 376 if self.__firsttime:
377 377
378 378 if xmin == None: xmin = numpy.nanmin(x)
379 379 if xmax == None: xmax = numpy.nanmax(x)
380 380 if ymin == None: ymin = numpy.nanmin(y)
381 381 if ymax == None: ymax = numpy.nanmax(y)
382 382
383 383 self.plot = self.__driver.createPmultiline(self.ax, x, y,
384 384 xmin, xmax,
385 385 ymin, ymax,
386 386 xlabel=xlabel,
387 387 ylabel=ylabel,
388 388 title=title,
389 389 **kwargs)
390 390 self.__firsttime = False
391 391 return
392 392
393 393 self.__driver.pmultiline(self.plot, x, y, xlabel=xlabel,
394 394 ylabel=ylabel,
395 395 title=title)
396 396
397 397 def pmultilineyaxis(self, x, y,
398 398 xmin=None, xmax=None,
399 399 ymin=None, ymax=None,
400 400 xlabel='', ylabel='',
401 401 title='',
402 402 **kwargs):
403 403
404 404 if self.__firsttime:
405 405
406 406 if xmin == None: xmin = numpy.nanmin(x)
407 407 if xmax == None: xmax = numpy.nanmax(x)
408 408 if ymin == None: ymin = numpy.nanmin(y)
409 409 if ymax == None: ymax = numpy.nanmax(y)
410 410
411 411 self.plot = self.__driver.createPmultilineYAxis(self.ax, x, y,
412 412 xmin, xmax,
413 413 ymin, ymax,
414 414 xlabel=xlabel,
415 415 ylabel=ylabel,
416 416 title=title,
417 417 **kwargs)
418 418 if self.xmin == None: self.xmin = xmin
419 419 if self.xmax == None: self.xmax = xmax
420 420 if self.ymin == None: self.ymin = ymin
421 421 if self.ymax == None: self.ymax = ymax
422 422
423 423 self.__firsttime = False
424 424 return
425 425
426 426 self.__driver.pmultilineyaxis(self.plot, x, y, xlabel=xlabel,
427 427 ylabel=ylabel,
428 428 title=title)
429 429
430 430 def pcolor(self, x, y, z,
431 431 xmin=None, xmax=None,
432 432 ymin=None, ymax=None,
433 433 zmin=None, zmax=None,
434 434 xlabel='', ylabel='',
435 435 title='', rti = False, colormap='jet',
436 436 **kwargs):
437 437
438 438 """
439 439 Input:
440 440 x :
441 441 y :
442 442 x :
443 443 xmin :
444 444 xmax :
445 445 ymin :
446 446 ymax :
447 447 zmin :
448 448 zmax :
449 449 xlabel :
450 450 ylabel :
451 451 title :
452 452 **kwargs : Los parametros aceptados son
453 453 ticksize=9,
454 454 cblabel=''
455 455 rti = True or False
456 456 """
457 457
458 458 if self.__firsttime:
459 459
460 460 if xmin == None: xmin = numpy.nanmin(x)
461 461 if xmax == None: xmax = numpy.nanmax(x)
462 462 if ymin == None: ymin = numpy.nanmin(y)
463 463 if ymax == None: ymax = numpy.nanmax(y)
464 464 if zmin == None: zmin = numpy.nanmin(z)
465 465 if zmax == None: zmax = numpy.nanmax(z)
466 466
467 467
468 468 self.plot = self.__driver.createPcolor(self.ax, x, y, z,
469 469 xmin, xmax,
470 470 ymin, ymax,
471 471 zmin, zmax,
472 472 xlabel=xlabel,
473 473 ylabel=ylabel,
474 474 title=title,
475 475 colormap=colormap,
476 476 **kwargs)
477 477
478 478 if self.xmin == None: self.xmin = xmin
479 479 if self.xmax == None: self.xmax = xmax
480 480 if self.ymin == None: self.ymin = ymin
481 481 if self.ymax == None: self.ymax = ymax
482 482 if self.zmin == None: self.zmin = zmin
483 483 if self.zmax == None: self.zmax = zmax
484 484
485 485 self.__firsttime = False
486 486 return
487 487
488 488 if rti:
489 489 self.__driver.addpcolor(self.ax, x, y, z, self.zmin, self.zmax,
490 490 xlabel=xlabel,
491 491 ylabel=ylabel,
492 492 title=title,
493 493 colormap=colormap)
494 494 return
495 495
496 496 self.__driver.pcolor(self.plot, z,
497 497 xlabel=xlabel,
498 498 ylabel=ylabel,
499 499 title=title)
500 500
501 501 def pcolorbuffer(self, x, y, z,
502 502 xmin=None, xmax=None,
503 503 ymin=None, ymax=None,
504 504 zmin=None, zmax=None,
505 505 xlabel='', ylabel='',
506 506 title='', rti = True, colormap='jet',
507 507 maxNumX = None, maxNumY = None,
508 508 **kwargs):
509 509
510 510 if maxNumX == None:
511 511 maxNumX = self.__MAXNUMX
512 512
513 513 if maxNumY == None:
514 514 maxNumY = self.__MAXNUMY
515 515
516 516 if self.__firsttime:
517 517 self.z_buffer = z
518 518 self.x_buffer = numpy.hstack((self.x_buffer, x))
519 519
520 520 if xmin == None: xmin = numpy.nanmin(x)
521 521 if xmax == None: xmax = numpy.nanmax(x)
522 522 if ymin == None: ymin = numpy.nanmin(y)
523 523 if ymax == None: ymax = numpy.nanmax(y)
524 524 if zmin == None: zmin = numpy.nanmin(z)
525 525 if zmax == None: zmax = numpy.nanmax(z)
526 526
527 527
528 528 self.plot = self.__driver.createPcolor(self.ax, self.x_buffer, y, z,
529 529 xmin, xmax,
530 530 ymin, ymax,
531 531 zmin, zmax,
532 532 xlabel=xlabel,
533 533 ylabel=ylabel,
534 534 title=title,
535 535 colormap=colormap,
536 536 **kwargs)
537 537
538 538 if self.xmin == None: self.xmin = xmin
539 539 if self.xmax == None: self.xmax = xmax
540 540 if self.ymin == None: self.ymin = ymin
541 541 if self.ymax == None: self.ymax = ymax
542 542 if self.zmin == None: self.zmin = zmin
543 543 if self.zmax == None: self.zmax = zmax
544 544
545 545 self.__firsttime = False
546 546 return
547 547
548 548 self.x_buffer = numpy.hstack((self.x_buffer, x[-1]))
549 549 self.z_buffer = numpy.hstack((self.z_buffer, z))
550 550
551 551 if self.decimationx == None:
552 552 deltax = float(self.xmax - self.xmin)/maxNumX
553 553 deltay = float(self.ymax - self.ymin)/maxNumY
554 554
555 555 resolutionx = self.x_buffer[2]-self.x_buffer[0]
556 556 resolutiony = y[1]-y[0]
557 557
558 558 self.decimationx = numpy.ceil(deltax / resolutionx)
559 559 self.decimationy = numpy.ceil(deltay / resolutiony)
560 560
561 561 z_buffer = self.z_buffer.reshape(-1,len(y))
562 562
563 563 x_buffer = self.x_buffer[::self.decimationx]
564 564 y_buffer = y[::self.decimationy]
565 565 z_buffer = z_buffer[::self.decimationx, ::self.decimationy]
566 566 #===================================================
567 567
568 568 x_buffer, y_buffer, z_buffer = self.__fillGaps(x_buffer, y_buffer, z_buffer)
569 569
570 570 self.__driver.addpcolorbuffer(self.ax, x_buffer, y_buffer, z_buffer, self.zmin, self.zmax,
571 571 xlabel=xlabel,
572 572 ylabel=ylabel,
573 573 title=title,
574 574 colormap=colormap)
575 575
576 576 def polar(self, x, y,
577 577 title='', xlabel='',ylabel='',**kwargs):
578 578
579 579 if self.__firsttime:
580 580 self.plot = self.__driver.createPolar(self.ax, x, y, title = title, xlabel = xlabel, ylabel = ylabel)
581 581 self.__firsttime = False
582 582 self.x_buffer = x
583 583 self.y_buffer = y
584 584 return
585 585
586 586 self.x_buffer = numpy.hstack((self.x_buffer,x))
587 587 self.y_buffer = numpy.hstack((self.y_buffer,y))
588 588 self.__driver.polar(self.plot, self.x_buffer, self.y_buffer, xlabel=xlabel,
589 589 ylabel=ylabel,
590 590 title=title)
591 591
592 592 def __fillGaps(self, x_buffer, y_buffer, z_buffer):
593 593
594 594 deltas = x_buffer[1:] - x_buffer[0:-1]
595 595 x_median = numpy.median(deltas)
596 596
597 597 index = numpy.where(deltas >= 2*x_median)
598 598
599 599 if len(index[0]) != 0:
600 600 z_buffer[index[0],::] = self.__missing
601 601 z_buffer = numpy.ma.masked_inside(z_buffer,0.99*self.__missing,1.01*self.__missing)
602 602
603 603 return x_buffer, y_buffer, z_buffer
604 604
605 605
606 606
607 607 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,326 +1,326
1 1 '''
2 2
3 3 @author: Daniel Suarez
4 4 '''
5 5
6 6 import os
7 7 import datetime
8 8 import numpy
9 9
10 10 from figure import Figure, isRealtime
11 11
12 12 class SpectraHeisScope(Figure):
13 13
14 14
15 15 isConfig = None
16 16 __nsubplots = None
17 17
18 18 WIDTHPROF = None
19 19 HEIGHTPROF = None
20 20 PREFIX = 'spc'
21 21
22 22 def __init__(self):
23 23
24 24 self.isConfig = False
25 25 self.__nsubplots = 1
26 26
27 27 self.WIDTH = 230
28 28 self.HEIGHT = 250
29 29 self.WIDTHPROF = 120
30 30 self.HEIGHTPROF = 0
31 31 self.counter_imagwr = 0
32 32
33 33 def getSubplots(self):
34 34
35 35 ncol = int(numpy.sqrt(self.nplots)+0.9)
36 36 nrow = int(self.nplots*1./ncol + 0.9)
37 37
38 38 return nrow, ncol
39 39
40 40 def setup(self, id, nplots, wintitle, show):
41 41
42 42 showprofile = False
43 43 self.__showprofile = showprofile
44 44 self.nplots = nplots
45 45
46 46 ncolspan = 1
47 47 colspan = 1
48 48 if showprofile:
49 49 ncolspan = 3
50 50 colspan = 2
51 51 self.__nsubplots = 2
52 52
53 53 self.createFigure(id = id,
54 54 wintitle = wintitle,
55 55 widthplot = self.WIDTH + self.WIDTHPROF,
56 56 heightplot = self.HEIGHT + self.HEIGHTPROF,
57 57 show = show)
58 58
59 59 nrow, ncol = self.getSubplots()
60 60
61 61 counter = 0
62 62 for y in range(nrow):
63 63 for x in range(ncol):
64 64
65 65 if counter >= self.nplots:
66 66 break
67 67
68 68 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
69 69
70 70 if showprofile:
71 71 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
72 72
73 73 counter += 1
74 74
75 75
76 76 def run(self, dataOut, id, wintitle="", channelList=None,
77 77 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
78 78 figpath='', figfile=None, ftp=False, wr_period=1, show=True,
79 79 server=None, folder=None, username=None, password=None):
80 80
81 81 """
82 82
83 83 Input:
84 84 dataOut :
85 85 id :
86 86 wintitle :
87 87 channelList :
88 88 xmin : None,
89 89 xmax : None,
90 90 ymin : None,
91 91 ymax : None,
92 92 """
93 93
94 94 if dataOut.realtime:
95 95 if not(isRealtime(utcdatatime = dataOut.utctime)):
96 96 print 'Skipping this plot function'
97 97 return
98 98
99 99 if channelList == None:
100 100 channelIndexList = dataOut.channelIndexList
101 101 else:
102 102 channelIndexList = []
103 103 for channel in channelList:
104 104 if channel not in dataOut.channelList:
105 105 raise ValueError, "Channel %d is not in dataOut.channelList"
106 106 channelIndexList.append(dataOut.channelList.index(channel))
107 107
108 108 # x = dataOut.heightList
109 109 c = 3E8
110 110 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
111 111 #deberia cambiar para el caso de 1Mhz y 100KHz
112 112 x = numpy.arange(-1*dataOut.nHeights/2.,dataOut.nHeights/2.)*(c/(2*deltaHeight*dataOut.nHeights*1000))
113 113 #para 1Mhz descomentar la siguiente linea
114 114 #x= x/(10000.0)
115 115 # y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
116 116 # y = y.real
117 117 factor = dataOut.normFactor
118 118 data = dataOut.data_spc / factor
119 119 datadB = 10.*numpy.log10(data)
120 120 y = datadB
121 121
122 122 #thisDatetime = dataOut.datatime
123 123 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
124 124 title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
125 125 xlabel = ""
126 126 #para 1Mhz descomentar la siguiente linea
127 127 #xlabel = "Frequency x 10000"
128 128 ylabel = "Intensity (dB)"
129 129
130 130 if not self.isConfig:
131 131 nplots = len(channelIndexList)
132 132
133 133 self.setup(id=id,
134 134 nplots=nplots,
135 135 wintitle=wintitle,
136 136 show=show)
137 137
138 138 if xmin == None: xmin = numpy.nanmin(x)
139 139 if xmax == None: xmax = numpy.nanmax(x)
140 140 if ymin == None: ymin = numpy.nanmin(y)
141 141 if ymax == None: ymax = numpy.nanmax(y)
142 142
143 143 self.isConfig = True
144 144
145 145 self.setWinTitle(title)
146 146
147 147 for i in range(len(self.axesList)):
148 148 ychannel = y[i,:]
149 149 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
150 150 title = "Channel %d: %4.2fdB: %s" %(i, numpy.max(ychannel), str_datetime)
151 151 axes = self.axesList[i]
152 152 axes.pline(x, ychannel,
153 153 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
154 154 xlabel=xlabel, ylabel=ylabel, title=title, grid='both')
155 155
156 156
157 157 self.draw()
158 158
159 159 if figfile == None:
160 160 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
161 161 figfile = self.getFilename(name = str_datetime)
162 162
163 163 if figpath != '':
164 164 self.counter_imagwr += 1
165 165 if (self.counter_imagwr>=wr_period):
166 166 # store png plot to local folder
167 167 self.saveFigure(figpath, figfile)
168 168 # store png plot to FTP server according to RT-Web format
169 169 #name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
170 170 #ftp_filename = os.path.join(figpath, name)
171 171 #self.saveFigure(figpath, ftp_filename)
172 172 self.counter_imagwr = 0
173 173
174 174 class RTIfromSpectraHeis(Figure):
175 175
176 176 isConfig = None
177 177 __nsubplots = None
178 178
179 179 PREFIX = 'rtinoise'
180 180
181 181 def __init__(self):
182 182
183 183 self.timerange = 24*60*60
184 184 self.isConfig = False
185 185 self.__nsubplots = 1
186 186
187 187 self.WIDTH = 820
188 188 self.HEIGHT = 200
189 189 self.WIDTHPROF = 120
190 190 self.HEIGHTPROF = 0
191 191 self.counter_imagwr = 0
192 192 self.xdata = None
193 193 self.ydata = None
194 194 self.figfile = None
195 195
196 196 def getSubplots(self):
197 197
198 198 ncol = 1
199 199 nrow = 1
200 200
201 201 return nrow, ncol
202 202
203 203 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
204 204
205 205 self.__showprofile = showprofile
206 206 self.nplots = nplots
207 207
208 208 ncolspan = 7
209 209 colspan = 6
210 210 self.__nsubplots = 2
211 211
212 212 self.createFigure(id = id,
213 213 wintitle = wintitle,
214 214 widthplot = self.WIDTH+self.WIDTHPROF,
215 215 heightplot = self.HEIGHT+self.HEIGHTPROF,
216 216 show = show)
217 217
218 218 nrow, ncol = self.getSubplots()
219 219
220 220 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
221 221
222 222
223 223 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
224 224 xmin=None, xmax=None, ymin=None, ymax=None,
225 225 timerange=None,
226 226 save=False, figpath='', figfile=None, ftp=False, wr_period=1, show=True,
227 227 server=None, folder=None, username=None, password=None):
228 228
229 229 if channelList == None:
230 230 channelIndexList = dataOut.channelIndexList
231 231 channelList = dataOut.channelList
232 232 else:
233 233 channelIndexList = []
234 234 for channel in channelList:
235 235 if channel not in dataOut.channelList:
236 236 raise ValueError, "Channel %d is not in dataOut.channelList"
237 237 channelIndexList.append(dataOut.channelList.index(channel))
238 238
239 239 if timerange != None:
240 240 self.timerange = timerange
241 241
242 242 tmin = None
243 243 tmax = None
244 244 x = dataOut.getTimeRange()
245 245 y = dataOut.getHeiRange()
246 246
247 247 factor = dataOut.normFactor
248 248 data = dataOut.data_spc / factor
249 249 data = numpy.average(data,axis=1)
250 250 datadB = 10*numpy.log10(data)
251 251
252 252 # factor = dataOut.normFactor
253 253 # noise = dataOut.getNoise()/factor
254 254 # noisedB = 10*numpy.log10(noise)
255 255
256 256 #thisDatetime = dataOut.datatime
257 257 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
258 258 title = wintitle + " RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
259 259 xlabel = "Local Time"
260 260 ylabel = "Intensity (dB)"
261 261
262 262 if not self.isConfig:
263 263
264 264 nplots = 1
265 265
266 266 self.setup(id=id,
267 267 nplots=nplots,
268 268 wintitle=wintitle,
269 269 showprofile=showprofile,
270 270 show=show)
271 271
272 tmin, tmax = self.getTimeLim(x, xmin, xmax)
272 tmin, tmax = self.getTimeLim(x, xmin, xmax, timezone = dataOut.timezone)
273 273 if ymin == None: ymin = numpy.nanmin(datadB)
274 274 if ymax == None: ymax = numpy.nanmax(datadB)
275 275
276 276 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
277 277 self.isConfig = True
278 278 self.figfile = figfile
279 279 self.xdata = numpy.array([])
280 280 self.ydata = numpy.array([])
281 281
282 282 self.setWinTitle(title)
283 283
284 284
285 285 # title = "RTI %s" %(thisDatetime.strftime("%d-%b-%Y"))
286 286 title = "RTI - %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
287 287
288 288 legendlabels = ["channel %d"%idchannel for idchannel in channelList]
289 289 axes = self.axesList[0]
290 290
291 291 self.xdata = numpy.hstack((self.xdata, x[0:1]))
292 292
293 293 if len(self.ydata)==0:
294 294 self.ydata = datadB[channelIndexList].reshape(-1,1)
295 295 else:
296 296 self.ydata = numpy.hstack((self.ydata, datadB[channelIndexList].reshape(-1,1)))
297 297
298 298
299 299 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
300 300 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
301 301 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='.', markersize=8, linestyle="solid", grid='both',
302 302 XAxisAsTime=True
303 303 )
304 304
305 305 self.draw()
306 306
307 307 if x[1] >= self.axesList[0].xmax:
308 308 self.counter_imagwr = wr_period
309 309 del self.xdata
310 310 del self.ydata
311 311 self.__isConfig = False
312 312
313 313 if self.figfile == None:
314 314 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
315 315 self.figfile = self.getFilename(name = str_datetime)
316 316
317 317 if figpath != '':
318 318 self.counter_imagwr += 1
319 319 if (self.counter_imagwr>=wr_period):
320 320 # store png plot to local folder
321 321 self.saveFigure(figpath, self.figfile)
322 322 # store png plot to FTP server according to RT-Web format
323 323 #name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
324 324 #ftp_filename = os.path.join(figpath, name)
325 325 #self.saveFigure(figpath, ftp_filename)
326 326 self.counter_imagwr = 0
Show file before | Show file after | Hide comments
@@ -1,1195 +1,1195
1 1 import os
2 2 import datetime
3 3 import numpy
4 4
5 5 from figure import Figure, isRealtime
6 6
7 7 class MomentsPlot(Figure):
8 8
9 9 isConfig = None
10 10 __nsubplots = None
11 11
12 12 WIDTHPROF = None
13 13 HEIGHTPROF = None
14 14 PREFIX = 'prm'
15 15
16 16 def __init__(self):
17 17
18 18 self.isConfig = False
19 19 self.__nsubplots = 1
20 20
21 21 self.WIDTH = 280
22 22 self.HEIGHT = 250
23 23 self.WIDTHPROF = 120
24 24 self.HEIGHTPROF = 0
25 25 self.counter_imagwr = 0
26 26
27 27 self.PLOT_CODE = 1
28 28 self.FTP_WEI = None
29 29 self.EXP_CODE = None
30 30 self.SUB_EXP_CODE = None
31 31 self.PLOT_POS = None
32 32
33 33 def getSubplots(self):
34 34
35 35 ncol = int(numpy.sqrt(self.nplots)+0.9)
36 36 nrow = int(self.nplots*1./ncol + 0.9)
37 37
38 38 return nrow, ncol
39 39
40 40 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
41 41
42 42 self.__showprofile = showprofile
43 43 self.nplots = nplots
44 44
45 45 ncolspan = 1
46 46 colspan = 1
47 47 if showprofile:
48 48 ncolspan = 3
49 49 colspan = 2
50 50 self.__nsubplots = 2
51 51
52 52 self.createFigure(id = id,
53 53 wintitle = wintitle,
54 54 widthplot = self.WIDTH + self.WIDTHPROF,
55 55 heightplot = self.HEIGHT + self.HEIGHTPROF,
56 56 show=show)
57 57
58 58 nrow, ncol = self.getSubplots()
59 59
60 60 counter = 0
61 61 for y in range(nrow):
62 62 for x in range(ncol):
63 63
64 64 if counter >= self.nplots:
65 65 break
66 66
67 67 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
68 68
69 69 if showprofile:
70 70 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
71 71
72 72 counter += 1
73 73
74 74 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
75 75 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
76 76 save=False, figpath='', figfile=None, show=True, ftp=False, wr_period=1,
77 77 server=None, folder=None, username=None, password=None,
78 78 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
79 79
80 80 """
81 81
82 82 Input:
83 83 dataOut :
84 84 id :
85 85 wintitle :
86 86 channelList :
87 87 showProfile :
88 88 xmin : None,
89 89 xmax : None,
90 90 ymin : None,
91 91 ymax : None,
92 92 zmin : None,
93 93 zmax : None
94 94 """
95 95
96 96 if dataOut.flagNoData:
97 97 return None
98 98
99 99 if realtime:
100 100 if not(isRealtime(utcdatatime = dataOut.utctime)):
101 101 print 'Skipping this plot function'
102 102 return
103 103
104 104 if channelList == None:
105 105 channelIndexList = dataOut.channelIndexList
106 106 else:
107 107 channelIndexList = []
108 108 for channel in channelList:
109 109 if channel not in dataOut.channelList:
110 110 raise ValueError, "Channel %d is not in dataOut.channelList"
111 111 channelIndexList.append(dataOut.channelList.index(channel))
112 112
113 113 factor = dataOut.normFactor
114 114 x = dataOut.abscissaList
115 115 y = dataOut.heightList
116 116
117 117 z = dataOut.data_pre[channelIndexList,:,:]/factor
118 118 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
119 119 avg = numpy.average(z, axis=1)
120 120 noise = dataOut.noise/factor
121 121
122 122 zdB = 10*numpy.log10(z)
123 123 avgdB = 10*numpy.log10(avg)
124 124 noisedB = 10*numpy.log10(noise)
125 125
126 126 #thisDatetime = dataOut.datatime
127 127 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
128 128 title = wintitle + " Parameters"
129 129 xlabel = "Velocity (m/s)"
130 130 ylabel = "Range (Km)"
131 131
132 132 if not self.isConfig:
133 133
134 134 nplots = len(channelIndexList)
135 135
136 136 self.setup(id=id,
137 137 nplots=nplots,
138 138 wintitle=wintitle,
139 139 showprofile=showprofile,
140 140 show=show)
141 141
142 142 if xmin == None: xmin = numpy.nanmin(x)
143 143 if xmax == None: xmax = numpy.nanmax(x)
144 144 if ymin == None: ymin = numpy.nanmin(y)
145 145 if ymax == None: ymax = numpy.nanmax(y)
146 146 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
147 147 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
148 148
149 149 self.FTP_WEI = ftp_wei
150 150 self.EXP_CODE = exp_code
151 151 self.SUB_EXP_CODE = sub_exp_code
152 152 self.PLOT_POS = plot_pos
153 153
154 154 self.isConfig = True
155 155
156 156 self.setWinTitle(title)
157 157
158 158 for i in range(self.nplots):
159 159 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
160 160 title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i]+1, noisedB[i], str_datetime)
161 161 axes = self.axesList[i*self.__nsubplots]
162 162 axes.pcolor(x, y, zdB[i,:,:],
163 163 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
164 164 xlabel=xlabel, ylabel=ylabel, title=title,
165 165 ticksize=9, cblabel='')
166 166 #Mean Line
167 167 mean = dataOut.data_param[i, 1, :]
168 168 axes.addpline(mean, y, idline=0, color="black", linestyle="solid", lw=1)
169 169
170 170 if self.__showprofile:
171 171 axes = self.axesList[i*self.__nsubplots +1]
172 172 axes.pline(avgdB[i], y,
173 173 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
174 174 xlabel='dB', ylabel='', title='',
175 175 ytick_visible=False,
176 176 grid='x')
177 177
178 178 noiseline = numpy.repeat(noisedB[i], len(y))
179 179 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
180 180
181 181 self.draw()
182 182
183 183 if figfile == None:
184 184 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
185 185 figfile = self.getFilename(name = str_datetime)
186 186
187 187 if figpath != '':
188 188 self.counter_imagwr += 1
189 189 if (self.counter_imagwr>=wr_period):
190 190 # store png plot to local folder
191 191 self.saveFigure(figpath, figfile)
192 192 # store png plot to FTP server according to RT-Web format
193 193 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
194 194 ftp_filename = os.path.join(figpath, name)
195 195 self.saveFigure(figpath, ftp_filename)
196 196 self.counter_imagwr = 0
197 197
198 198 class SkyMapPlot(Figure):
199 199
200 200 __isConfig = None
201 201 __nsubplots = None
202 202
203 203 WIDTHPROF = None
204 204 HEIGHTPROF = None
205 205 PREFIX = 'prm'
206 206
207 207 def __init__(self):
208 208
209 209 self.__isConfig = False
210 210 self.__nsubplots = 1
211 211
212 212 # self.WIDTH = 280
213 213 # self.HEIGHT = 250
214 214 self.WIDTH = 600
215 215 self.HEIGHT = 600
216 216 self.WIDTHPROF = 120
217 217 self.HEIGHTPROF = 0
218 218 self.counter_imagwr = 0
219 219
220 220 self.PLOT_CODE = 1
221 221 self.FTP_WEI = None
222 222 self.EXP_CODE = None
223 223 self.SUB_EXP_CODE = None
224 224 self.PLOT_POS = None
225 225
226 226 def getSubplots(self):
227 227
228 228 ncol = int(numpy.sqrt(self.nplots)+0.9)
229 229 nrow = int(self.nplots*1./ncol + 0.9)
230 230
231 231 return nrow, ncol
232 232
233 233 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
234 234
235 235 self.__showprofile = showprofile
236 236 self.nplots = nplots
237 237
238 238 ncolspan = 1
239 239 colspan = 1
240 240
241 241 self.createFigure(id = id,
242 242 wintitle = wintitle,
243 243 widthplot = self.WIDTH, #+ self.WIDTHPROF,
244 244 heightplot = self.HEIGHT,# + self.HEIGHTPROF,
245 245 show=show)
246 246
247 247 nrow, ncol = 1,1
248 248 counter = 0
249 249 x = 0
250 250 y = 0
251 251 self.addAxes(1, 1, 0, 0, 1, 1, True)
252 252
253 253 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
254 254 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
255 255 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
256 256 server=None, folder=None, username=None, password=None,
257 257 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
258 258
259 259 """
260 260
261 261 Input:
262 262 dataOut :
263 263 id :
264 264 wintitle :
265 265 channelList :
266 266 showProfile :
267 267 xmin : None,
268 268 xmax : None,
269 269 ymin : None,
270 270 ymax : None,
271 271 zmin : None,
272 272 zmax : None
273 273 """
274 274
275 275 arrayParameters = dataOut.data_param
276 276 error = arrayParameters[:,-1]
277 277 indValid = numpy.where(error == 0)[0]
278 278 finalMeteor = arrayParameters[indValid,:]
279 279 finalAzimuth = finalMeteor[:,4]
280 280 finalZenith = finalMeteor[:,5]
281 281
282 282 x = finalAzimuth*numpy.pi/180
283 283 y = finalZenith
284 284
285 285
286 286 #thisDatetime = dataOut.datatime
287 287 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
288 288 title = wintitle + " Parameters"
289 289 xlabel = "Zonal Zenith Angle (deg) "
290 290 ylabel = "Meridional Zenith Angle (deg)"
291 291
292 292 if not self.__isConfig:
293 293
294 294 nplots = 1
295 295
296 296 self.setup(id=id,
297 297 nplots=nplots,
298 298 wintitle=wintitle,
299 299 showprofile=showprofile,
300 300 show=show)
301 301
302 302 self.FTP_WEI = ftp_wei
303 303 self.EXP_CODE = exp_code
304 304 self.SUB_EXP_CODE = sub_exp_code
305 305 self.PLOT_POS = plot_pos
306 306 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
307 307 self.firstdate = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
308 308 self.__isConfig = True
309 309
310 310 self.setWinTitle(title)
311 311
312 312 i = 0
313 313 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
314 314
315 315 axes = self.axesList[i*self.__nsubplots]
316 316 nevents = axes.x_buffer.shape[0] + x.shape[0]
317 317 title = "Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n" %(self.firstdate,str_datetime,nevents)
318 318 axes.polar(x, y,
319 319 title=title, xlabel=xlabel, ylabel=ylabel,
320 320 ticksize=9, cblabel='')
321 321
322 322 self.draw()
323 323
324 324 if save:
325 325
326 326 self.counter_imagwr += 1
327 327 if (self.counter_imagwr==wr_period):
328 328
329 329 if figfile == None:
330 330 figfile = self.getFilename(name = self.name)
331 331 self.saveFigure(figpath, figfile)
332 332
333 333 if ftp:
334 334 #provisionalmente envia archivos en el formato de la web en tiempo real
335 335 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
336 336 path = '%s%03d' %(self.PREFIX, self.id)
337 337 ftp_file = os.path.join(path,'ftp','%s.png'%name)
338 338 self.saveFigure(figpath, ftp_file)
339 339 ftp_filename = os.path.join(figpath,ftp_file)
340 340
341 341
342 342 try:
343 343 self.sendByFTP(ftp_filename, server, folder, username, password)
344 344 except:
345 345 self.counter_imagwr = 0
346 346 raise ValueError, 'Error FTP'
347 347
348 348 self.counter_imagwr = 0
349 349
350 350
351 351 class WindProfilerPlot(Figure):
352 352
353 353 __isConfig = None
354 354 __nsubplots = None
355 355
356 356 WIDTHPROF = None
357 357 HEIGHTPROF = None
358 358 PREFIX = 'wind'
359 359
360 360 def __init__(self):
361 361
362 362 self.timerange = 2*60*60
363 363 self.__isConfig = False
364 364 self.__nsubplots = 1
365 365
366 366 self.WIDTH = 800
367 367 self.HEIGHT = 150
368 368 self.WIDTHPROF = 120
369 369 self.HEIGHTPROF = 0
370 370 self.counter_imagwr = 0
371 371
372 372 self.PLOT_CODE = 0
373 373 self.FTP_WEI = None
374 374 self.EXP_CODE = None
375 375 self.SUB_EXP_CODE = None
376 376 self.PLOT_POS = None
377 377 self.tmin = None
378 378 self.tmax = None
379 379
380 380 self.xmin = None
381 381 self.xmax = None
382 382
383 383 self.figfile = None
384 384
385 385 def getSubplots(self):
386 386
387 387 ncol = 1
388 388 nrow = self.nplots
389 389
390 390 return nrow, ncol
391 391
392 392 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
393 393
394 394 self.__showprofile = showprofile
395 395 self.nplots = nplots
396 396
397 397 ncolspan = 1
398 398 colspan = 1
399 399
400 400 self.createFigure(id = id,
401 401 wintitle = wintitle,
402 402 widthplot = self.WIDTH + self.WIDTHPROF,
403 403 heightplot = self.HEIGHT + self.HEIGHTPROF,
404 404 show=show)
405 405
406 406 nrow, ncol = self.getSubplots()
407 407
408 408 counter = 0
409 409 for y in range(nrow):
410 410 if counter >= self.nplots:
411 411 break
412 412
413 413 self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
414 414 counter += 1
415 415
416 416 def run(self, dataOut, id, wintitle="", channelList=None,
417 417 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
418 418 zmax_ver = None, zmin_ver = None, SNRmin = None, SNRmax = None,
419 419 timerange=None, SNRthresh = None,
420 420 save=False, figpath='', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
421 421 server=None, folder=None, username=None, password=None,
422 422 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
423 423 """
424 424
425 425 Input:
426 426 dataOut :
427 427 id :
428 428 wintitle :
429 429 channelList :
430 430 showProfile :
431 431 xmin : None,
432 432 xmax : None,
433 433 ymin : None,
434 434 ymax : None,
435 435 zmin : None,
436 436 zmax : None
437 437 """
438 438
439 439 if channelList == None:
440 440 channelIndexList = dataOut.channelIndexList
441 441 else:
442 442 channelIndexList = []
443 443 for channel in channelList:
444 444 if channel not in dataOut.channelList:
445 445 raise ValueError, "Channel %d is not in dataOut.channelList"
446 446 channelIndexList.append(dataOut.channelList.index(channel))
447 447
448 448 if timerange != None:
449 449 self.timerange = timerange
450 450
451 451 tmin = None
452 452 tmax = None
453 453
454 454 x = dataOut.getTimeRange1()
455 455 # y = dataOut.heightList
456 456 y = dataOut.heightList
457 457
458 458 z = dataOut.data_output.copy()
459 459 nplots = z.shape[0] #Number of wind dimensions estimated
460 460 nplotsw = nplots
461 461
462 462 #If there is a SNR function defined
463 463 if dataOut.data_SNR != None:
464 464 nplots += 1
465 465 SNR = dataOut.data_SNR
466 466 SNRavg = numpy.average(SNR, axis=0)
467 467
468 468 SNRdB = 10*numpy.log10(SNR)
469 469 SNRavgdB = 10*numpy.log10(SNRavg)
470 470
471 471 if SNRthresh == None: SNRthresh = -5.0
472 472 ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
473 473
474 474 for i in range(nplotsw):
475 475 z[i,ind] = numpy.nan
476 476
477 477
478 478 showprofile = False
479 479 # thisDatetime = dataOut.datatime
480 480 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
481 481 title = wintitle + "Wind"
482 482 xlabel = ""
483 483 ylabel = "Range (Km)"
484 484
485 485 if not self.__isConfig:
486 486
487 487 self.setup(id=id,
488 488 nplots=nplots,
489 489 wintitle=wintitle,
490 490 showprofile=showprofile,
491 491 show=show)
492 492
493 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
493 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
494 494
495 495 if ymin == None: ymin = numpy.nanmin(y)
496 496 if ymax == None: ymax = numpy.nanmax(y)
497 497
498 498 if zmax == None: zmax = numpy.nanmax(abs(z[range(2),:]))
499 499 #if numpy.isnan(zmax): zmax = 50
500 500 if zmin == None: zmin = -zmax
501 501
502 502 if nplotsw == 3:
503 503 if zmax_ver == None: zmax_ver = numpy.nanmax(abs(z[2,:]))
504 504 if zmin_ver == None: zmin_ver = -zmax_ver
505 505
506 506 if dataOut.data_SNR != None:
507 507 if SNRmin == None: SNRmin = numpy.nanmin(SNRavgdB)
508 508 if SNRmax == None: SNRmax = numpy.nanmax(SNRavgdB)
509 509
510 510 self.FTP_WEI = ftp_wei
511 511 self.EXP_CODE = exp_code
512 512 self.SUB_EXP_CODE = sub_exp_code
513 513 self.PLOT_POS = plot_pos
514 514
515 515 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
516 516 self.__isConfig = True
517 517
518 518
519 519 self.setWinTitle(title)
520 520
521 521 if ((self.xmax - x[1]) < (x[1]-x[0])):
522 522 x[1] = self.xmax
523 523
524 524 strWind = ['Zonal', 'Meridional', 'Vertical']
525 525 strCb = ['Velocity (m/s)','Velocity (m/s)','Velocity (cm/s)']
526 526 zmaxVector = [zmax, zmax, zmax_ver]
527 527 zminVector = [zmin, zmin, zmin_ver]
528 528 windFactor = [1,1,100]
529 529
530 530 for i in range(nplotsw):
531 531
532 532 title = "%s Wind: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
533 533 axes = self.axesList[i*self.__nsubplots]
534 534
535 535 z1 = z[i,:].reshape((1,-1))*windFactor[i]
536 536
537 537 axes.pcolorbuffer(x, y, z1,
538 538 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
539 539 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
540 540 ticksize=9, cblabel=strCb[i], cbsize="1%", colormap="RdBu_r" )
541 541
542 542 if dataOut.data_SNR != None:
543 543 i += 1
544 544 title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
545 545 axes = self.axesList[i*self.__nsubplots]
546 546
547 547 SNRavgdB = SNRavgdB.reshape((1,-1))
548 548
549 549 axes.pcolorbuffer(x, y, SNRavgdB,
550 550 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
551 551 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
552 552 ticksize=9, cblabel='', cbsize="1%", colormap="jet")
553 553
554 554 self.draw()
555 555
556 556 if self.figfile == None:
557 557 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
558 558 self.figfile = self.getFilename(name = str_datetime)
559 559
560 560 if figpath != '':
561 561
562 562 self.counter_imagwr += 1
563 563 if (self.counter_imagwr>=wr_period):
564 564 # store png plot to local folder
565 565 self.saveFigure(figpath, self.figfile)
566 566 # store png plot to FTP server according to RT-Web format
567 567 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
568 568 ftp_filename = os.path.join(figpath, name)
569 569 self.saveFigure(figpath, ftp_filename)
570 570
571 571 self.counter_imagwr = 0
572 572
573 573 if x[1] >= self.axesList[0].xmax:
574 574 self.counter_imagwr = wr_period
575 575 self.__isConfig = False
576 576 self.figfile = None
577 577
578 578
579 579 class ParametersPlot(Figure):
580 580
581 581 __isConfig = None
582 582 __nsubplots = None
583 583
584 584 WIDTHPROF = None
585 585 HEIGHTPROF = None
586 586 PREFIX = 'prm'
587 587
588 588 def __init__(self):
589 589
590 590 self.timerange = 2*60*60
591 591 self.__isConfig = False
592 592 self.__nsubplots = 1
593 593
594 594 self.WIDTH = 800
595 595 self.HEIGHT = 150
596 596 self.WIDTHPROF = 120
597 597 self.HEIGHTPROF = 0
598 598 self.counter_imagwr = 0
599 599
600 600 self.PLOT_CODE = 0
601 601 self.FTP_WEI = None
602 602 self.EXP_CODE = None
603 603 self.SUB_EXP_CODE = None
604 604 self.PLOT_POS = None
605 605 self.tmin = None
606 606 self.tmax = None
607 607
608 608 self.xmin = None
609 609 self.xmax = None
610 610
611 611 self.figfile = None
612 612
613 613 def getSubplots(self):
614 614
615 615 ncol = 1
616 616 nrow = self.nplots
617 617
618 618 return nrow, ncol
619 619
620 620 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
621 621
622 622 self.__showprofile = showprofile
623 623 self.nplots = nplots
624 624
625 625 ncolspan = 1
626 626 colspan = 1
627 627
628 628 self.createFigure(id = id,
629 629 wintitle = wintitle,
630 630 widthplot = self.WIDTH + self.WIDTHPROF,
631 631 heightplot = self.HEIGHT + self.HEIGHTPROF,
632 632 show=show)
633 633
634 634 nrow, ncol = self.getSubplots()
635 635
636 636 counter = 0
637 637 for y in range(nrow):
638 638 for x in range(ncol):
639 639
640 640 if counter >= self.nplots:
641 641 break
642 642
643 643 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
644 644
645 645 if showprofile:
646 646 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
647 647
648 648 counter += 1
649 649
650 650 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
651 651 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,timerange=None,
652 652 parameterIndex = None, onlyPositive = False,
653 653 SNRthresh = -numpy.inf, SNR = True, SNRmin = None, SNRmax = None,
654 654
655 655 zlabel = "", parameterName = "", parameterObject = "data_param",
656 656 save=False, figpath='', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
657 657 server=None, folder=None, username=None, password=None,
658 658 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
659 659
660 660 """
661 661
662 662 Input:
663 663 dataOut :
664 664 id :
665 665 wintitle :
666 666 channelList :
667 667 showProfile :
668 668 xmin : None,
669 669 xmax : None,
670 670 ymin : None,
671 671 ymax : None,
672 672 zmin : None,
673 673 zmax : None
674 674 """
675 675
676 676 data_param = getattr(dataOut, parameterObject)
677 677
678 678 if channelList == None:
679 679 channelIndexList = numpy.arange(data_param.shape[0])
680 680 else:
681 681 channelIndexList = numpy.array(channelList)
682 682
683 683 nchan = len(channelIndexList) #Number of channels being plotted
684 684
685 685 if timerange != None:
686 686 self.timerange = timerange
687 687
688 688 #tmin = None
689 689 #tmax = None
690 690 if parameterIndex == None:
691 691 parameterIndex = 1
692 692 x = dataOut.getTimeRange1()
693 693 y = dataOut.heightList
694 694 z = data_param[channelIndexList,parameterIndex,:].copy()
695 695
696 696 zRange = dataOut.abscissaList
697 697 nplots = z.shape[0] #Number of wind dimensions estimated
698 698 # thisDatetime = dataOut.datatime
699 699
700 700 if dataOut.data_SNR != None:
701 701 SNRarray = dataOut.data_SNR[channelIndexList,:]
702 702 SNRdB = 10*numpy.log10(SNRarray)
703 703 # SNRavgdB = 10*numpy.log10(SNRavg)
704 704 ind = numpy.where(SNRdB < 10**(SNRthresh/10))
705 705 z[ind] = numpy.nan
706 706
707 707 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
708 708 title = wintitle + " Parameters Plot" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
709 709 xlabel = ""
710 710 ylabel = "Range (Km)"
711 711
712 712 if SNR: nplots = 2*nplots
713 713
714 714 if onlyPositive:
715 715 colormap = "jet"
716 716 zmin = 0
717 717 else: colormap = "RdBu_r"
718 718
719 719 if not self.__isConfig:
720 720
721 721 self.setup(id=id,
722 722 nplots=nplots,
723 723 wintitle=wintitle,
724 724 showprofile=showprofile,
725 725 show=show)
726 726
727 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
727 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
728 728
729 729 if ymin == None: ymin = numpy.nanmin(y)
730 730 if ymax == None: ymax = numpy.nanmax(y)
731 731 if zmin == None: zmin = numpy.nanmin(zRange)
732 732 if zmax == None: zmax = numpy.nanmax(zRange)
733 733
734 734 if SNR != None:
735 735 if SNRmin == None: SNRmin = numpy.nanmin(SNRdB)
736 736 if SNRmax == None: SNRmax = numpy.nanmax(SNRdB)
737 737
738 738 self.FTP_WEI = ftp_wei
739 739 self.EXP_CODE = exp_code
740 740 self.SUB_EXP_CODE = sub_exp_code
741 741 self.PLOT_POS = plot_pos
742 742
743 743 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
744 744 self.__isConfig = True
745 745 self.figfile = figfile
746 746
747 747 self.setWinTitle(title)
748 748
749 749 if ((self.xmax - x[1]) < (x[1]-x[0])):
750 750 x[1] = self.xmax
751 751
752 752 for i in range(nchan):
753 753 if SNR: j = 2*i
754 754 else: j = i
755 755
756 756 title = "%s Channel %d: %s" %(parameterName, channelIndexList[i]+1, thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
757 757
758 758 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
759 759 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
760 760 axes = self.axesList[j*self.__nsubplots]
761 761 z1 = z[i,:].reshape((1,-1))
762 762 axes.pcolorbuffer(x, y, z1,
763 763 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
764 764 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap=colormap,
765 765 ticksize=9, cblabel=zlabel, cbsize="1%")
766 766
767 767 if SNR:
768 768 title = "Channel %d Signal Noise Ratio (SNR): %s" %(channelIndexList[i]+1, thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
769 769 axes = self.axesList[(j + 1)*self.__nsubplots]
770 770 z1 = SNRdB[i,:].reshape((1,-1))
771 771 axes.pcolorbuffer(x, y, z1,
772 772 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
773 773 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap="jet",
774 774 ticksize=9, cblabel=zlabel, cbsize="1%")
775 775
776 776
777 777
778 778 self.draw()
779 779
780 780 if self.figfile == None:
781 781 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
782 782 self.figfile = self.getFilename(name = str_datetime)
783 783
784 784 if figpath != '':
785 785
786 786 self.counter_imagwr += 1
787 787 if (self.counter_imagwr>=wr_period):
788 788 # store png plot to local folder
789 789 self.saveFigure(figpath, self.figfile)
790 790 # store png plot to FTP server according to RT-Web format
791 791 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
792 792 ftp_filename = os.path.join(figpath, name)
793 793 self.saveFigure(figpath, ftp_filename)
794 794
795 795 self.counter_imagwr = 0
796 796
797 797 if x[1] >= self.axesList[0].xmax:
798 798 self.counter_imagwr = wr_period
799 799 self.__isConfig = False
800 800 self.figfile = None
801 801
802 802
803 803 class SpectralFittingPlot(Figure):
804 804
805 805 __isConfig = None
806 806 __nsubplots = None
807 807
808 808 WIDTHPROF = None
809 809 HEIGHTPROF = None
810 810 PREFIX = 'prm'
811 811
812 812
813 813 N = None
814 814 ippSeconds = None
815 815
816 816 def __init__(self):
817 817 self.__isConfig = False
818 818 self.__nsubplots = 1
819 819
820 820 self.WIDTH = 450
821 821 self.HEIGHT = 250
822 822 self.WIDTHPROF = 0
823 823 self.HEIGHTPROF = 0
824 824
825 825 def getSubplots(self):
826 826
827 827 ncol = int(numpy.sqrt(self.nplots)+0.9)
828 828 nrow = int(self.nplots*1./ncol + 0.9)
829 829
830 830 return nrow, ncol
831 831
832 832 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
833 833
834 834 showprofile = False
835 835 self.__showprofile = showprofile
836 836 self.nplots = nplots
837 837
838 838 ncolspan = 5
839 839 colspan = 4
840 840 if showprofile:
841 841 ncolspan = 5
842 842 colspan = 4
843 843 self.__nsubplots = 2
844 844
845 845 self.createFigure(id = id,
846 846 wintitle = wintitle,
847 847 widthplot = self.WIDTH + self.WIDTHPROF,
848 848 heightplot = self.HEIGHT + self.HEIGHTPROF,
849 849 show=show)
850 850
851 851 nrow, ncol = self.getSubplots()
852 852
853 853 counter = 0
854 854 for y in range(nrow):
855 855 for x in range(ncol):
856 856
857 857 if counter >= self.nplots:
858 858 break
859 859
860 860 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
861 861
862 862 if showprofile:
863 863 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
864 864
865 865 counter += 1
866 866
867 867 def run(self, dataOut, id, cutHeight=None, fit=False, wintitle="", channelList=None, showprofile=True,
868 868 xmin=None, xmax=None, ymin=None, ymax=None,
869 869 save=False, figpath='./', figfile=None, show=True):
870 870
871 871 """
872 872
873 873 Input:
874 874 dataOut :
875 875 id :
876 876 wintitle :
877 877 channelList :
878 878 showProfile :
879 879 xmin : None,
880 880 xmax : None,
881 881 zmin : None,
882 882 zmax : None
883 883 """
884 884
885 885 if cutHeight==None:
886 886 h=270
887 887 heightindex = numpy.abs(cutHeight - dataOut.heightList).argmin()
888 888 cutHeight = dataOut.heightList[heightindex]
889 889
890 890 factor = dataOut.normFactor
891 891 x = dataOut.abscissaList[:-1]
892 892 #y = dataOut.getHeiRange()
893 893
894 894 z = dataOut.data_pre[:,:,heightindex]/factor
895 895 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
896 896 avg = numpy.average(z, axis=1)
897 897 listChannels = z.shape[0]
898 898
899 899 #Reconstruct Function
900 900 if fit==True:
901 901 groupArray = dataOut.groupList
902 902 listChannels = groupArray.reshape((groupArray.size))
903 903 listChannels.sort()
904 904 spcFitLine = numpy.zeros(z.shape)
905 905 constants = dataOut.constants
906 906
907 907 nGroups = groupArray.shape[0]
908 908 nChannels = groupArray.shape[1]
909 909 nProfiles = z.shape[1]
910 910
911 911 for f in range(nGroups):
912 912 groupChann = groupArray[f,:]
913 913 p = dataOut.data_param[f,:,heightindex]
914 914 # p = numpy.array([ 89.343967,0.14036615,0.17086219,18.89835291,1.58388365,1.55099167])
915 915 fitLineAux = dataOut.library.modelFunction(p, constants)*nProfiles
916 916 fitLineAux = fitLineAux.reshape((nChannels,nProfiles))
917 917 spcFitLine[groupChann,:] = fitLineAux
918 918 # spcFitLine = spcFitLine/factor
919 919
920 920 z = z[listChannels,:]
921 921 spcFitLine = spcFitLine[listChannels,:]
922 922 spcFitLinedB = 10*numpy.log10(spcFitLine)
923 923
924 924 zdB = 10*numpy.log10(z)
925 925 #thisDatetime = dataOut.datatime
926 926 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
927 927 title = wintitle + " Doppler Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
928 928 xlabel = "Velocity (m/s)"
929 929 ylabel = "Spectrum"
930 930
931 931 if not self.__isConfig:
932 932
933 933 nplots = listChannels.size
934 934
935 935 self.setup(id=id,
936 936 nplots=nplots,
937 937 wintitle=wintitle,
938 938 showprofile=showprofile,
939 939 show=show)
940 940
941 941 if xmin == None: xmin = numpy.nanmin(x)
942 942 if xmax == None: xmax = numpy.nanmax(x)
943 943 if ymin == None: ymin = numpy.nanmin(zdB)
944 944 if ymax == None: ymax = numpy.nanmax(zdB)+2
945 945
946 946 self.__isConfig = True
947 947
948 948 self.setWinTitle(title)
949 949 for i in range(self.nplots):
950 950 # title = "Channel %d: %4.2fdB" %(dataOut.channelList[i]+1, noisedB[i])
951 951 title = "Height %4.1f km\nChannel %d:" %(cutHeight, listChannels[i]+1)
952 952 axes = self.axesList[i*self.__nsubplots]
953 953 if fit == False:
954 954 axes.pline(x, zdB[i,:],
955 955 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
956 956 xlabel=xlabel, ylabel=ylabel, title=title
957 957 )
958 958 if fit == True:
959 959 fitline=spcFitLinedB[i,:]
960 960 y=numpy.vstack([zdB[i,:],fitline] )
961 961 legendlabels=['Data','Fitting']
962 962 axes.pmultilineyaxis(x, y,
963 963 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
964 964 xlabel=xlabel, ylabel=ylabel, title=title,
965 965 legendlabels=legendlabels, marker=None,
966 966 linestyle='solid', grid='both')
967 967
968 968 self.draw()
969 969
970 970 if save:
971 971 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
972 972 if figfile == None:
973 973 figfile = self.getFilename(name = date)
974 974
975 975 self.saveFigure(figpath, figfile)
976 976
977 977
978 978 class EWDriftsPlot(Figure):
979 979
980 980 __isConfig = None
981 981 __nsubplots = None
982 982
983 983 WIDTHPROF = None
984 984 HEIGHTPROF = None
985 985 PREFIX = 'drift'
986 986
987 987 def __init__(self):
988 988
989 989 self.timerange = 2*60*60
990 990 self.isConfig = False
991 991 self.__nsubplots = 1
992 992
993 993 self.WIDTH = 800
994 994 self.HEIGHT = 150
995 995 self.WIDTHPROF = 120
996 996 self.HEIGHTPROF = 0
997 997 self.counter_imagwr = 0
998 998
999 999 self.PLOT_CODE = 0
1000 1000 self.FTP_WEI = None
1001 1001 self.EXP_CODE = None
1002 1002 self.SUB_EXP_CODE = None
1003 1003 self.PLOT_POS = None
1004 1004 self.tmin = None
1005 1005 self.tmax = None
1006 1006
1007 1007 self.xmin = None
1008 1008 self.xmax = None
1009 1009
1010 1010 self.figfile = None
1011 1011
1012 1012 def getSubplots(self):
1013 1013
1014 1014 ncol = 1
1015 1015 nrow = self.nplots
1016 1016
1017 1017 return nrow, ncol
1018 1018
1019 1019 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1020 1020
1021 1021 self.__showprofile = showprofile
1022 1022 self.nplots = nplots
1023 1023
1024 1024 ncolspan = 1
1025 1025 colspan = 1
1026 1026
1027 1027 self.createFigure(id = id,
1028 1028 wintitle = wintitle,
1029 1029 widthplot = self.WIDTH + self.WIDTHPROF,
1030 1030 heightplot = self.HEIGHT + self.HEIGHTPROF,
1031 1031 show=show)
1032 1032
1033 1033 nrow, ncol = self.getSubplots()
1034 1034
1035 1035 counter = 0
1036 1036 for y in range(nrow):
1037 1037 if counter >= self.nplots:
1038 1038 break
1039 1039
1040 1040 self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
1041 1041 counter += 1
1042 1042
1043 1043 def run(self, dataOut, id, wintitle="", channelList=None,
1044 1044 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
1045 1045 zmaxVertical = None, zminVertical = None, zmaxZonal = None, zminZonal = None,
1046 1046 timerange=None, SNRthresh = -numpy.inf, SNRmin = None, SNRmax = None, SNR_1 = False,
1047 1047 save=False, figpath='', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
1048 1048 server=None, folder=None, username=None, password=None,
1049 1049 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1050 1050 """
1051 1051
1052 1052 Input:
1053 1053 dataOut :
1054 1054 id :
1055 1055 wintitle :
1056 1056 channelList :
1057 1057 showProfile :
1058 1058 xmin : None,
1059 1059 xmax : None,
1060 1060 ymin : None,
1061 1061 ymax : None,
1062 1062 zmin : None,
1063 1063 zmax : None
1064 1064 """
1065 1065
1066 1066 if timerange != None:
1067 1067 self.timerange = timerange
1068 1068
1069 1069 tmin = None
1070 1070 tmax = None
1071 1071
1072 1072 x = dataOut.getTimeRange1()
1073 1073 # y = dataOut.heightList
1074 1074 y = dataOut.heightList
1075 1075
1076 1076 z = dataOut.data_output
1077 1077 nplots = z.shape[0] #Number of wind dimensions estimated
1078 1078 nplotsw = nplots
1079 1079
1080 1080 #If there is a SNR function defined
1081 1081 if dataOut.data_SNR != None:
1082 1082 nplots += 1
1083 1083 SNR = dataOut.data_SNR
1084 1084
1085 1085 if SNR_1:
1086 1086 SNR += 1
1087 1087
1088 1088 SNRavg = numpy.average(SNR, axis=0)
1089 1089
1090 1090 SNRdB = 10*numpy.log10(SNR)
1091 1091 SNRavgdB = 10*numpy.log10(SNRavg)
1092 1092
1093 1093 ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
1094 1094
1095 1095 for i in range(nplotsw):
1096 1096 z[i,ind] = numpy.nan
1097 1097
1098 1098
1099 1099 showprofile = False
1100 1100 # thisDatetime = dataOut.datatime
1101 1101 thisDatetime = datetime.datetime.utcfromtimestamp(x[1])
1102 1102 title = wintitle + " EW Drifts"
1103 1103 xlabel = ""
1104 1104 ylabel = "Height (Km)"
1105 1105
1106 1106 if not self.__isConfig:
1107 1107
1108 1108 self.setup(id=id,
1109 1109 nplots=nplots,
1110 1110 wintitle=wintitle,
1111 1111 showprofile=showprofile,
1112 1112 show=show)
1113 1113
1114 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
1114 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
1115 1115
1116 1116 if ymin == None: ymin = numpy.nanmin(y)
1117 1117 if ymax == None: ymax = numpy.nanmax(y)
1118 1118
1119 1119 if zmaxZonal == None: zmaxZonal = numpy.nanmax(abs(z[0,:]))
1120 1120 if zminZonal == None: zminZonal = -zmaxZonal
1121 1121 if zmaxVertical == None: zmaxVertical = numpy.nanmax(abs(z[1,:]))
1122 1122 if zminVertical == None: zminVertical = -zmaxVertical
1123 1123
1124 1124 if dataOut.data_SNR != None:
1125 1125 if SNRmin == None: SNRmin = numpy.nanmin(SNRavgdB)
1126 1126 if SNRmax == None: SNRmax = numpy.nanmax(SNRavgdB)
1127 1127
1128 1128 self.FTP_WEI = ftp_wei
1129 1129 self.EXP_CODE = exp_code
1130 1130 self.SUB_EXP_CODE = sub_exp_code
1131 1131 self.PLOT_POS = plot_pos
1132 1132
1133 1133 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1134 1134 self.__isConfig = True
1135 1135
1136 1136
1137 1137 self.setWinTitle(title)
1138 1138
1139 1139 if ((self.xmax - x[1]) < (x[1]-x[0])):
1140 1140 x[1] = self.xmax
1141 1141
1142 1142 strWind = ['Zonal','Vertical']
1143 1143 strCb = 'Velocity (m/s)'
1144 1144 zmaxVector = [zmaxZonal, zmaxVertical]
1145 1145 zminVector = [zminZonal, zminVertical]
1146 1146
1147 1147 for i in range(nplotsw):
1148 1148
1149 1149 title = "%s Drifts: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1150 1150 axes = self.axesList[i*self.__nsubplots]
1151 1151
1152 1152 z1 = z[i,:].reshape((1,-1))
1153 1153
1154 1154 axes.pcolorbuffer(x, y, z1,
1155 1155 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
1156 1156 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
1157 1157 ticksize=9, cblabel=strCb, cbsize="1%", colormap="RdBu_r")
1158 1158
1159 1159 if dataOut.data_SNR != None:
1160 1160 i += 1
1161 1161 if SNR_1:
1162 1162 title = "Signal Noise Ratio + 1 (SNR+1): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1163 1163 else:
1164 1164 title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1165 1165 axes = self.axesList[i*self.__nsubplots]
1166 1166 SNRavgdB = SNRavgdB.reshape((1,-1))
1167 1167
1168 1168 axes.pcolorbuffer(x, y, SNRavgdB,
1169 1169 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
1170 1170 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
1171 1171 ticksize=9, cblabel='', cbsize="1%", colormap="jet")
1172 1172
1173 1173 self.draw()
1174 1174
1175 1175 if self.figfile == None:
1176 1176 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
1177 1177 self.figfile = self.getFilename(name = str_datetime)
1178 1178
1179 1179 if figpath != '':
1180 1180
1181 1181 self.counter_imagwr += 1
1182 1182 if (self.counter_imagwr>=wr_period):
1183 1183 # store png plot to local folder
1184 1184 self.saveFigure(figpath, self.figfile)
1185 1185 # store png plot to FTP server according to RT-Web format
1186 1186 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
1187 1187 ftp_filename = os.path.join(figpath, name)
1188 1188 self.saveFigure(figpath, ftp_filename)
1189 1189
1190 1190 self.counter_imagwr = 0
1191 1191
1192 1192 if x[1] >= self.axesList[0].xmax:
1193 1193 self.counter_imagwr = wr_period
1194 1194 self.__isConfig = False
1195 1195 self.figfile = None No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1356 +1,1356
1 1 '''
2 2 @author: Daniel Suarez
3 3 '''
4 4 import os
5 5 import datetime
6 6 import numpy
7 7
8 8 from figure import Figure, isRealtime
9 9
10 10 class SpectraPlot(Figure):
11 11
12 12 isConfig = None
13 13 __nsubplots = None
14 14
15 15 WIDTHPROF = None
16 16 HEIGHTPROF = None
17 17 PREFIX = 'spc'
18 18
19 19 def __init__(self):
20 20
21 21 self.isConfig = False
22 22 self.__nsubplots = 1
23 23
24 24 self.WIDTH = 280
25 25 self.HEIGHT = 250
26 26 self.WIDTHPROF = 120
27 27 self.HEIGHTPROF = 0
28 28 self.counter_imagwr = 0
29 29
30 30 self.PLOT_CODE = 1
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 def getSubplots(self):
37 37
38 38 ncol = int(numpy.sqrt(self.nplots)+0.9)
39 39 nrow = int(self.nplots*1./ncol + 0.9)
40 40
41 41 return nrow, ncol
42 42
43 43 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
44 44
45 45 self.__showprofile = showprofile
46 46 self.nplots = nplots
47 47
48 48 ncolspan = 1
49 49 colspan = 1
50 50 if showprofile:
51 51 ncolspan = 3
52 52 colspan = 2
53 53 self.__nsubplots = 2
54 54
55 55 self.createFigure(id = id,
56 56 wintitle = wintitle,
57 57 widthplot = self.WIDTH + self.WIDTHPROF,
58 58 heightplot = self.HEIGHT + self.HEIGHTPROF,
59 59 show=show)
60 60
61 61 nrow, ncol = self.getSubplots()
62 62
63 63 counter = 0
64 64 for y in range(nrow):
65 65 for x in range(ncol):
66 66
67 67 if counter >= self.nplots:
68 68 break
69 69
70 70 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
71 71
72 72 if showprofile:
73 73 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
74 74
75 75 counter += 1
76 76
77 77 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
78 78 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
79 79 save=False, figpath='', figfile=None, show=True, ftp=False, wr_period=1,
80 80 server=None, folder=None, username=None, password=None,
81 81 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
82 82
83 83 """
84 84
85 85 Input:
86 86 dataOut :
87 87 id :
88 88 wintitle :
89 89 channelList :
90 90 showProfile :
91 91 xmin : None,
92 92 xmax : None,
93 93 ymin : None,
94 94 ymax : None,
95 95 zmin : None,
96 96 zmax : None
97 97 """
98 98
99 99 if dataOut.flagNoData:
100 100 return 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"
114 114 channelIndexList.append(dataOut.channelList.index(channel))
115 115
116 116 factor = dataOut.normFactor
117 117
118 118 x = dataOut.getVelRange(1)
119 119 y = dataOut.getHeiRange()
120 120
121 121 z = dataOut.data_spc[channelIndexList,:,:]/factor
122 122 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
123 123 avg = numpy.average(z, axis=1)
124 124 #avg = numpy.nanmean(z, axis=1)
125 125 noise = dataOut.noise/factor
126 126
127 127 zdB = 10*numpy.log10(z)
128 128 avgdB = 10*numpy.log10(avg)
129 129 noisedB = 10*numpy.log10(noise)
130 130
131 131 #thisDatetime = dataOut.datatime
132 132 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
133 133 title = wintitle + " Spectra"
134 134 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
135 135 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
136 136
137 137 xlabel = "Velocity (m/s)"
138 138 ylabel = "Range (Km)"
139 139
140 140 if not self.isConfig:
141 141
142 142 nplots = len(channelIndexList)
143 143
144 144 self.setup(id=id,
145 145 nplots=nplots,
146 146 wintitle=wintitle,
147 147 showprofile=showprofile,
148 148 show=show)
149 149
150 150 if xmin == None: xmin = numpy.nanmin(x)
151 151 if xmax == None: xmax = numpy.nanmax(x)
152 152 if ymin == None: ymin = numpy.nanmin(y)
153 153 if ymax == None: ymax = numpy.nanmax(y)
154 154 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
155 155 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
156 156
157 157 self.FTP_WEI = ftp_wei
158 158 self.EXP_CODE = exp_code
159 159 self.SUB_EXP_CODE = sub_exp_code
160 160 self.PLOT_POS = plot_pos
161 161
162 162 self.isConfig = True
163 163
164 164 self.setWinTitle(title)
165 165
166 166 for i in range(self.nplots):
167 167 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
168 168 title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i]+1, noisedB[i], str_datetime)
169 169 if len(dataOut.beam.codeList) != 0:
170 170 title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[i]+1, noisedB[i], dataOut.beam.azimuthList[i], dataOut.beam.zenithList[i], str_datetime)
171 171
172 172 axes = self.axesList[i*self.__nsubplots]
173 173 axes.pcolor(x, y, zdB[i,:,:],
174 174 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
175 175 xlabel=xlabel, ylabel=ylabel, title=title,
176 176 ticksize=9, cblabel='')
177 177
178 178 if self.__showprofile:
179 179 axes = self.axesList[i*self.__nsubplots +1]
180 180 axes.pline(avgdB[i], y,
181 181 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
182 182 xlabel='dB', ylabel='', title='',
183 183 ytick_visible=False,
184 184 grid='x')
185 185
186 186 noiseline = numpy.repeat(noisedB[i], len(y))
187 187 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
188 188
189 189 self.draw()
190 190
191 191 if figfile == None:
192 192 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
193 193 figfile = self.getFilename(name = str_datetime)
194 194 name = str_datetime
195 195 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
196 196 name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
197 197 figfile = self.getFilename(name)
198 198 if figpath != '':
199 199 self.counter_imagwr += 1
200 200 if (self.counter_imagwr>=wr_period):
201 201 # store png plot to local folder
202 202 self.saveFigure(figpath, figfile)
203 203 # store png plot to FTP server according to RT-Web format
204 204 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
205 205 ftp_filename = os.path.join(figpath, name)
206 206 self.saveFigure(figpath, ftp_filename)
207 207 self.counter_imagwr = 0
208 208
209 209
210 210 class CrossSpectraPlot(Figure):
211 211
212 212 isConfig = None
213 213 __nsubplots = None
214 214
215 215 WIDTH = None
216 216 HEIGHT = None
217 217 WIDTHPROF = None
218 218 HEIGHTPROF = None
219 219 PREFIX = 'cspc'
220 220
221 221 def __init__(self):
222 222
223 223 self.isConfig = False
224 224 self.__nsubplots = 4
225 225 self.counter_imagwr = 0
226 226 self.WIDTH = 250
227 227 self.HEIGHT = 250
228 228 self.WIDTHPROF = 0
229 229 self.HEIGHTPROF = 0
230 230
231 231 self.PLOT_CODE = 1
232 232 self.FTP_WEI = None
233 233 self.EXP_CODE = None
234 234 self.SUB_EXP_CODE = None
235 235 self.PLOT_POS = None
236 236
237 237 def getSubplots(self):
238 238
239 239 ncol = 4
240 240 nrow = self.nplots
241 241
242 242 return nrow, ncol
243 243
244 244 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
245 245
246 246 self.__showprofile = showprofile
247 247 self.nplots = nplots
248 248
249 249 ncolspan = 1
250 250 colspan = 1
251 251
252 252 self.createFigure(id = id,
253 253 wintitle = wintitle,
254 254 widthplot = self.WIDTH + self.WIDTHPROF,
255 255 heightplot = self.HEIGHT + self.HEIGHTPROF,
256 256 show=True)
257 257
258 258 nrow, ncol = self.getSubplots()
259 259
260 260 counter = 0
261 261 for y in range(nrow):
262 262 for x in range(ncol):
263 263 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
264 264
265 265 counter += 1
266 266
267 267 def run(self, dataOut, id, wintitle="", pairsList=None,
268 268 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
269 269 save=False, figpath='', figfile=None, ftp=False, wr_period=1,
270 270 power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
271 271 server=None, folder=None, username=None, password=None,
272 272 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
273 273
274 274 """
275 275
276 276 Input:
277 277 dataOut :
278 278 id :
279 279 wintitle :
280 280 channelList :
281 281 showProfile :
282 282 xmin : None,
283 283 xmax : None,
284 284 ymin : None,
285 285 ymax : None,
286 286 zmin : None,
287 287 zmax : None
288 288 """
289 289
290 290 if pairsList == None:
291 291 pairsIndexList = dataOut.pairsIndexList
292 292 else:
293 293 pairsIndexList = []
294 294 for pair in pairsList:
295 295 if pair not in dataOut.pairsList:
296 296 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
297 297 pairsIndexList.append(dataOut.pairsList.index(pair))
298 298
299 299 if pairsIndexList == []:
300 300 return
301 301
302 302 if len(pairsIndexList) > 4:
303 303 pairsIndexList = pairsIndexList[0:4]
304 304 factor = dataOut.normFactor
305 305 x = dataOut.getVelRange(1)
306 306 y = dataOut.getHeiRange()
307 307 z = dataOut.data_spc[:,:,:]/factor
308 308 # z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
309 309 avg = numpy.abs(numpy.average(z, axis=1))
310 310 noise = dataOut.noise/factor
311 311
312 312 zdB = 10*numpy.log10(z)
313 313 avgdB = 10*numpy.log10(avg)
314 314 noisedB = 10*numpy.log10(noise)
315 315
316 316
317 317 #thisDatetime = dataOut.datatime
318 318 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
319 319 title = wintitle + " Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
320 320 xlabel = "Velocity (m/s)"
321 321 ylabel = "Range (Km)"
322 322
323 323 if not self.isConfig:
324 324
325 325 nplots = len(pairsIndexList)
326 326
327 327 self.setup(id=id,
328 328 nplots=nplots,
329 329 wintitle=wintitle,
330 330 showprofile=False,
331 331 show=show)
332 332
333 333 if xmin == None: xmin = numpy.nanmin(x)
334 334 if xmax == None: xmax = numpy.nanmax(x)
335 335 if ymin == None: ymin = numpy.nanmin(y)
336 336 if ymax == None: ymax = numpy.nanmax(y)
337 337 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
338 338 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
339 339
340 340 self.FTP_WEI = ftp_wei
341 341 self.EXP_CODE = exp_code
342 342 self.SUB_EXP_CODE = sub_exp_code
343 343 self.PLOT_POS = plot_pos
344 344
345 345 self.isConfig = True
346 346
347 347 self.setWinTitle(title)
348 348
349 349 for i in range(self.nplots):
350 350 pair = dataOut.pairsList[pairsIndexList[i]]
351 351 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
352 352 title = "Ch%d: %4.2fdB: %s" %(pair[0], noisedB[pair[0]], str_datetime)
353 353 zdB = 10.*numpy.log10(dataOut.data_spc[pair[0],:,:]/factor)
354 354 axes0 = self.axesList[i*self.__nsubplots]
355 355 axes0.pcolor(x, y, zdB,
356 356 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
357 357 xlabel=xlabel, ylabel=ylabel, title=title,
358 358 ticksize=9, colormap=power_cmap, cblabel='')
359 359
360 360 title = "Ch%d: %4.2fdB: %s" %(pair[1], noisedB[pair[1]], str_datetime)
361 361 zdB = 10.*numpy.log10(dataOut.data_spc[pair[1],:,:]/factor)
362 362 axes0 = self.axesList[i*self.__nsubplots+1]
363 363 axes0.pcolor(x, y, zdB,
364 364 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
365 365 xlabel=xlabel, ylabel=ylabel, title=title,
366 366 ticksize=9, colormap=power_cmap, cblabel='')
367 367
368 368 coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
369 369 coherence = numpy.abs(coherenceComplex)
370 370 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
371 371 phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
372 372
373 373 title = "Coherence %d%d" %(pair[0], pair[1])
374 374 axes0 = self.axesList[i*self.__nsubplots+2]
375 375 axes0.pcolor(x, y, coherence,
376 376 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
377 377 xlabel=xlabel, ylabel=ylabel, title=title,
378 378 ticksize=9, colormap=coherence_cmap, cblabel='')
379 379
380 380 title = "Phase %d%d" %(pair[0], pair[1])
381 381 axes0 = self.axesList[i*self.__nsubplots+3]
382 382 axes0.pcolor(x, y, phase,
383 383 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
384 384 xlabel=xlabel, ylabel=ylabel, title=title,
385 385 ticksize=9, colormap=phase_cmap, cblabel='')
386 386
387 387
388 388
389 389 self.draw()
390 390
391 391 if figfile == None:
392 392 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
393 393 figfile = self.getFilename(name = str_datetime)
394 394
395 395 if figpath != '':
396 396 self.counter_imagwr += 1
397 397 if (self.counter_imagwr>=wr_period):
398 398 # store png plot to local folder
399 399 self.saveFigure(figpath, figfile)
400 400 # store png plot to FTP server according to RT-Web format
401 401 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
402 402 ftp_filename = os.path.join(figpath, name)
403 403 self.saveFigure(figpath, ftp_filename)
404 404 self.counter_imagwr = 0
405 405
406 406
407 407 class RTIPlot(Figure):
408 408
409 409 __isConfig = None
410 410 __nsubplots = None
411 411
412 412 WIDTHPROF = None
413 413 HEIGHTPROF = None
414 414 PREFIX = 'rti'
415 415
416 416 def __init__(self):
417 417
418 418 self.timerange = 2*60*60
419 419 self.__isConfig = False
420 420 self.__nsubplots = 1
421 421
422 422 self.WIDTH = 800
423 423 self.HEIGHT = 150
424 424 self.WIDTHPROF = 120
425 425 self.HEIGHTPROF = 0
426 426 self.counter_imagwr = 0
427 427
428 428 self.PLOT_CODE = 0
429 429 self.FTP_WEI = None
430 430 self.EXP_CODE = None
431 431 self.SUB_EXP_CODE = None
432 432 self.PLOT_POS = None
433 433 self.tmin = None
434 434 self.tmax = None
435 435
436 436 self.xmin = None
437 437 self.xmax = None
438 438
439 439 self.figfile = None
440 440
441 441 def getSubplots(self):
442 442
443 443 ncol = 1
444 444 nrow = self.nplots
445 445
446 446 return nrow, ncol
447 447
448 448 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
449 449
450 450 self.__showprofile = showprofile
451 451 self.nplots = nplots
452 452
453 453 ncolspan = 1
454 454 colspan = 1
455 455 if showprofile:
456 456 ncolspan = 7
457 457 colspan = 6
458 458 self.__nsubplots = 2
459 459
460 460 self.createFigure(id = id,
461 461 wintitle = wintitle,
462 462 widthplot = self.WIDTH + self.WIDTHPROF,
463 463 heightplot = self.HEIGHT + self.HEIGHTPROF,
464 464 show=show)
465 465
466 466 nrow, ncol = self.getSubplots()
467 467
468 468 counter = 0
469 469 for y in range(nrow):
470 470 for x in range(ncol):
471 471
472 472 if counter >= self.nplots:
473 473 break
474 474
475 475 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
476 476
477 477 if showprofile:
478 478 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
479 479
480 480 counter += 1
481 481
482 482 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
483 483 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
484 484 timerange=None,
485 485 save=False, figpath='', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
486 486 server=None, folder=None, username=None, password=None,
487 487 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
488 488
489 489 """
490 490
491 491 Input:
492 492 dataOut :
493 493 id :
494 494 wintitle :
495 495 channelList :
496 496 showProfile :
497 497 xmin : None,
498 498 xmax : None,
499 499 ymin : None,
500 500 ymax : None,
501 501 zmin : None,
502 502 zmax : None
503 503 """
504 504
505 505 if channelList == None:
506 506 channelIndexList = dataOut.channelIndexList
507 507 else:
508 508 channelIndexList = []
509 509 for channel in channelList:
510 510 if channel not in dataOut.channelList:
511 511 raise ValueError, "Channel %d is not in dataOut.channelList"
512 512 channelIndexList.append(dataOut.channelList.index(channel))
513 513
514 514 if timerange != None:
515 515 self.timerange = timerange
516 516
517 517 #tmin = None
518 518 #tmax = None
519 519 factor = dataOut.normFactor
520 520 x = dataOut.getTimeRange()
521 521 y = dataOut.getHeiRange()
522 522
523 523 z = dataOut.data_spc[channelIndexList,:,:]/factor
524 524 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
525 525 avg = numpy.average(z, axis=1)
526 526
527 527 avgdB = 10.*numpy.log10(avg)
528 528
529 529
530 530 # thisDatetime = dataOut.datatime
531 531 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
532 532 title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
533 533 xlabel = ""
534 534 ylabel = "Range (Km)"
535 535
536 536 if not self.__isConfig:
537 537
538 538 nplots = len(channelIndexList)
539 539
540 540 self.setup(id=id,
541 541 nplots=nplots,
542 542 wintitle=wintitle,
543 543 showprofile=showprofile,
544 544 show=show)
545 545
546 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
546 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
547 547
548 548 # if timerange != None:
549 549 # self.timerange = timerange
550 # self.xmin, self.tmax = self.getTimeLim(x, xmin, xmax, timerange)
550 # self.xmin, self.tmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
551 551
552 552
553 553
554 554 if ymin == None: ymin = numpy.nanmin(y)
555 555 if ymax == None: ymax = numpy.nanmax(y)
556 556 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
557 557 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
558 558
559 559 self.FTP_WEI = ftp_wei
560 560 self.EXP_CODE = exp_code
561 561 self.SUB_EXP_CODE = sub_exp_code
562 562 self.PLOT_POS = plot_pos
563 563
564 564 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
565 565 self.__isConfig = True
566 566 self.figfile = figfile
567 567
568 568 self.setWinTitle(title)
569 569
570 570 if ((self.xmax - x[1]) < (x[1]-x[0])):
571 571 x[1] = self.xmax
572 572
573 573 for i in range(self.nplots):
574 574 title = "Channel %d: %s" %(dataOut.channelList[i]+1, thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
575 575 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
576 576 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
577 577 axes = self.axesList[i*self.__nsubplots]
578 578 zdB = avgdB[i].reshape((1,-1))
579 579 axes.pcolorbuffer(x, y, zdB,
580 580 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
581 581 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
582 582 ticksize=9, cblabel='', cbsize="1%")
583 583
584 584 if self.__showprofile:
585 585 axes = self.axesList[i*self.__nsubplots +1]
586 586 axes.pline(avgdB[i], y,
587 587 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
588 588 xlabel='dB', ylabel='', title='',
589 589 ytick_visible=False,
590 590 grid='x')
591 591
592 592 self.draw()
593 593
594 594 if self.figfile == None:
595 595 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
596 596 self.figfile = self.getFilename(name = str_datetime)
597 597
598 598 if figpath != '':
599 599
600 600 self.counter_imagwr += 1
601 601 if (self.counter_imagwr>=wr_period):
602 602 # store png plot to local folder
603 603 self.saveFigure(figpath, self.figfile)
604 604 # store png plot to FTP server according to RT-Web format
605 605 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
606 606 ftp_filename = os.path.join(figpath, name)
607 607 self.saveFigure(figpath, ftp_filename)
608 608
609 609 self.counter_imagwr = 0
610 610
611 611 if x[1] >= self.axesList[0].xmax:
612 612 self.counter_imagwr = wr_period
613 613 self.__isConfig = False
614 614 self.figfile = None
615 615
616 616 class CoherenceMap(Figure):
617 617 isConfig = None
618 618 __nsubplots = None
619 619
620 620 WIDTHPROF = None
621 621 HEIGHTPROF = None
622 622 PREFIX = 'cmap'
623 623
624 624 def __init__(self):
625 625 self.timerange = 2*60*60
626 626 self.isConfig = False
627 627 self.__nsubplots = 1
628 628
629 629 self.WIDTH = 800
630 630 self.HEIGHT = 150
631 631 self.WIDTHPROF = 120
632 632 self.HEIGHTPROF = 0
633 633 self.counter_imagwr = 0
634 634
635 635 self.PLOT_CODE = 3
636 636 self.FTP_WEI = None
637 637 self.EXP_CODE = None
638 638 self.SUB_EXP_CODE = None
639 639 self.PLOT_POS = None
640 640 self.counter_imagwr = 0
641 641
642 642 self.xmin = None
643 643 self.xmax = None
644 644
645 645 def getSubplots(self):
646 646 ncol = 1
647 647 nrow = self.nplots*2
648 648
649 649 return nrow, ncol
650 650
651 651 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
652 652 self.__showprofile = showprofile
653 653 self.nplots = nplots
654 654
655 655 ncolspan = 1
656 656 colspan = 1
657 657 if showprofile:
658 658 ncolspan = 7
659 659 colspan = 6
660 660 self.__nsubplots = 2
661 661
662 662 self.createFigure(id = id,
663 663 wintitle = wintitle,
664 664 widthplot = self.WIDTH + self.WIDTHPROF,
665 665 heightplot = self.HEIGHT + self.HEIGHTPROF,
666 666 show=True)
667 667
668 668 nrow, ncol = self.getSubplots()
669 669
670 670 for y in range(nrow):
671 671 for x in range(ncol):
672 672
673 673 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
674 674
675 675 if showprofile:
676 676 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
677 677
678 678 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
679 679 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
680 680 timerange=None,
681 681 save=False, figpath='', figfile=None, ftp=False, wr_period=1,
682 682 coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
683 683 server=None, folder=None, username=None, password=None,
684 684 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
685 685
686 686 if pairsList == None:
687 687 pairsIndexList = dataOut.pairsIndexList
688 688 else:
689 689 pairsIndexList = []
690 690 for pair in pairsList:
691 691 if pair not in dataOut.pairsList:
692 692 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
693 693 pairsIndexList.append(dataOut.pairsList.index(pair))
694 694
695 695 if timerange != None:
696 696 self.timerange = timerange
697 697
698 698 if pairsIndexList == []:
699 699 return
700 700
701 701 if len(pairsIndexList) > 4:
702 702 pairsIndexList = pairsIndexList[0:4]
703 703
704 704 # tmin = None
705 705 # tmax = None
706 706 x = dataOut.getTimeRange()
707 707 y = dataOut.getHeiRange()
708 708
709 709 #thisDatetime = dataOut.datatime
710 710 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
711 711 title = wintitle + " CoherenceMap" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
712 712 xlabel = ""
713 713 ylabel = "Range (Km)"
714 714
715 715 if not self.isConfig:
716 716 nplots = len(pairsIndexList)
717 717 self.setup(id=id,
718 718 nplots=nplots,
719 719 wintitle=wintitle,
720 720 showprofile=showprofile,
721 721 show=show)
722 722
723 #tmin, tmax = self.getTimeLim(x, xmin, xmax)
723 #tmin, tmax = self.getTimeLim(x, xmin, xmax, timezone = dataOut.timezone)
724 724
725 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
725 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
726 726
727 727 if ymin == None: ymin = numpy.nanmin(y)
728 728 if ymax == None: ymax = numpy.nanmax(y)
729 729 if zmin == None: zmin = 0.
730 730 if zmax == None: zmax = 1.
731 731
732 732 self.FTP_WEI = ftp_wei
733 733 self.EXP_CODE = exp_code
734 734 self.SUB_EXP_CODE = sub_exp_code
735 735 self.PLOT_POS = plot_pos
736 736
737 737 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
738 738
739 739 self.isConfig = True
740 740
741 741 self.setWinTitle(title)
742 742
743 743 if ((self.xmax - x[1]) < (x[1]-x[0])):
744 744 x[1] = self.xmax
745 745
746 746 for i in range(self.nplots):
747 747
748 748 pair = dataOut.pairsList[pairsIndexList[i]]
749 749
750 750 ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
751 751 powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
752 752 powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
753 753
754 754
755 755 avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
756 756 coherence = numpy.abs(avgcoherenceComplex)
757 757
758 758 z = coherence.reshape((1,-1))
759 759
760 760 counter = 0
761 761
762 762 title = "Coherence %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
763 763 axes = self.axesList[i*self.__nsubplots*2]
764 764 axes.pcolorbuffer(x, y, z,
765 765 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
766 766 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
767 767 ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
768 768
769 769 if self.__showprofile:
770 770 counter += 1
771 771 axes = self.axesList[i*self.__nsubplots*2 + counter]
772 772 axes.pline(coherence, y,
773 773 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
774 774 xlabel='', ylabel='', title='', ticksize=7,
775 775 ytick_visible=False, nxticks=5,
776 776 grid='x')
777 777
778 778 counter += 1
779 779
780 780 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
781 781
782 782 z = phase.reshape((1,-1))
783 783
784 784 title = "Phase %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
785 785 axes = self.axesList[i*self.__nsubplots*2 + counter]
786 786 axes.pcolorbuffer(x, y, z,
787 787 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
788 788 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
789 789 ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
790 790
791 791 if self.__showprofile:
792 792 counter += 1
793 793 axes = self.axesList[i*self.__nsubplots*2 + counter]
794 794 axes.pline(phase, y,
795 795 xmin=-180, xmax=180, ymin=ymin, ymax=ymax,
796 796 xlabel='', ylabel='', title='', ticksize=7,
797 797 ytick_visible=False, nxticks=4,
798 798 grid='x')
799 799
800 800 self.draw()
801 801
802 802 if x[1] >= self.axesList[0].xmax:
803 803 self.counter_imagwr = wr_period
804 804 self.__isConfig = False
805 805
806 806 if figfile == None:
807 807 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
808 808 figfile = self.getFilename(name = str_datetime)
809 809
810 810 if figpath != '':
811 811
812 812 self.counter_imagwr += 1
813 813 if (self.counter_imagwr>=wr_period):
814 814 # store png plot to local folder
815 815 self.saveFigure(figpath, figfile)
816 816 # store png plot to FTP server according to RT-Web format
817 817 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
818 818 ftp_filename = os.path.join(figpath, name)
819 819 self.saveFigure(figpath, ftp_filename)
820 820
821 821 self.counter_imagwr = 0
822 822
823 823 class PowerProfile(Figure):
824 824 isConfig = None
825 825 __nsubplots = None
826 826
827 827 WIDTHPROF = None
828 828 HEIGHTPROF = None
829 829 PREFIX = 'spcprofile'
830 830
831 831 def __init__(self):
832 832 self.isConfig = False
833 833 self.__nsubplots = 1
834 834
835 835 self.WIDTH = 300
836 836 self.HEIGHT = 500
837 837 self.counter_imagwr = 0
838 838
839 839 def getSubplots(self):
840 840 ncol = 1
841 841 nrow = 1
842 842
843 843 return nrow, ncol
844 844
845 845 def setup(self, id, nplots, wintitle, show):
846 846
847 847 self.nplots = nplots
848 848
849 849 ncolspan = 1
850 850 colspan = 1
851 851
852 852 self.createFigure(id = id,
853 853 wintitle = wintitle,
854 854 widthplot = self.WIDTH,
855 855 heightplot = self.HEIGHT,
856 856 show=show)
857 857
858 858 nrow, ncol = self.getSubplots()
859 859
860 860 counter = 0
861 861 for y in range(nrow):
862 862 for x in range(ncol):
863 863 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
864 864
865 865 def run(self, dataOut, id, wintitle="", channelList=None,
866 866 xmin=None, xmax=None, ymin=None, ymax=None,
867 867 save=False, figpath='', figfile=None, show=True, wr_period=1,
868 868 server=None, folder=None, username=None, password=None,):
869 869
870 870 if dataOut.flagNoData:
871 871 return None
872 872
873 873 if channelList == None:
874 874 channelIndexList = dataOut.channelIndexList
875 875 channelList = dataOut.channelList
876 876 else:
877 877 channelIndexList = []
878 878 for channel in channelList:
879 879 if channel not in dataOut.channelList:
880 880 raise ValueError, "Channel %d is not in dataOut.channelList"
881 881 channelIndexList.append(dataOut.channelList.index(channel))
882 882
883 883 try:
884 884 factor = dataOut.normFactor
885 885 except:
886 886 factor = 1
887 887
888 888 y = dataOut.getHeiRange()
889 889
890 890 #for voltage
891 891 if dataOut.type == 'Voltage':
892 892 x = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
893 893 x = x.real
894 894 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
895 895
896 896 #for spectra
897 897 if dataOut.type == 'Spectra':
898 898 x = dataOut.data_spc[channelIndexList,:,:]/factor
899 899 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
900 900 x = numpy.average(x, axis=1)
901 901
902 902
903 903 xdB = 10*numpy.log10(x)
904 904
905 905 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
906 906 title = wintitle + " Power Profile %s" %(thisDatetime.strftime("%d-%b-%Y"))
907 907 xlabel = "dB"
908 908 ylabel = "Range (Km)"
909 909
910 910 if not self.isConfig:
911 911
912 912 nplots = 1
913 913
914 914 self.setup(id=id,
915 915 nplots=nplots,
916 916 wintitle=wintitle,
917 917 show=show)
918 918
919 919 if ymin == None: ymin = numpy.nanmin(y)
920 920 if ymax == None: ymax = numpy.nanmax(y)
921 921 if xmin == None: xmin = numpy.nanmin(xdB)*0.9
922 922 if xmax == None: xmax = numpy.nanmax(xdB)*0.9
923 923
924 924 self.__isConfig = True
925 925
926 926 self.setWinTitle(title)
927 927
928 928 title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
929 929 axes = self.axesList[0]
930 930
931 931 legendlabels = ["channel %d"%x for x in channelList]
932 932 axes.pmultiline(xdB, y,
933 933 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
934 934 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
935 935 ytick_visible=True, nxticks=5,
936 936 grid='x')
937 937
938 938 self.draw()
939 939
940 940 if figfile == None:
941 941 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
942 942 figfile = self.getFilename(name = str_datetime)
943 943
944 944 if figpath != '':
945 945 self.counter_imagwr += 1
946 946 if (self.counter_imagwr>=wr_period):
947 947 # store png plot to local folder
948 948 self.saveFigure(figpath, figfile)
949 949 # store png plot to FTP server according to RT-Web format
950 950 #name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
951 951 #ftp_filename = os.path.join(figpath, name)
952 952 #self.saveFigure(figpath, ftp_filename)
953 953 self.counter_imagwr = 0
954 954
955 955
956 956
957 957 class Noise(Figure):
958 958
959 959 isConfig = None
960 960 __nsubplots = None
961 961
962 962 PREFIX = 'noise'
963 963
964 964 def __init__(self):
965 965
966 966 self.timerange = 24*60*60
967 967 self.isConfig = False
968 968 self.__nsubplots = 1
969 969 self.counter_imagwr = 0
970 970 self.WIDTH = 600
971 971 self.HEIGHT = 300
972 972 self.WIDTHPROF = 120
973 973 self.HEIGHTPROF = 0
974 974 self.xdata = None
975 975 self.ydata = None
976 976
977 977 self.PLOT_CODE = 17
978 978 self.FTP_WEI = None
979 979 self.EXP_CODE = None
980 980 self.SUB_EXP_CODE = None
981 981 self.PLOT_POS = None
982 982 self.figfile = None
983 983
984 984 def getSubplots(self):
985 985
986 986 ncol = 1
987 987 nrow = 1
988 988
989 989 return nrow, ncol
990 990
991 991 def openfile(self, filename):
992 992 f = open(filename,'w+')
993 993 f.write('\n\n')
994 994 f.write('JICAMARCA RADIO OBSERVATORY - Noise \n')
995 995 f.write('DD MM YYYY HH MM SS Channel0 Channel1 Channel2 Channel3\n\n' )
996 996 f.close()
997 997
998 998 def save_data(self, filename_phase, data, data_datetime):
999 999 f=open(filename_phase,'a')
1000 1000 timetuple_data = data_datetime.timetuple()
1001 1001 day = str(timetuple_data.tm_mday)
1002 1002 month = str(timetuple_data.tm_mon)
1003 1003 year = str(timetuple_data.tm_year)
1004 1004 hour = str(timetuple_data.tm_hour)
1005 1005 minute = str(timetuple_data.tm_min)
1006 1006 second = str(timetuple_data.tm_sec)
1007 1007 f.write(day+' '+month+' '+year+' '+hour+' '+minute+' '+second+' '+str(data[0])+' '+str(data[1])+' '+str(data[2])+' '+str(data[3])+'\n')
1008 1008 f.close()
1009 1009
1010 1010
1011 1011 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1012 1012
1013 1013 self.__showprofile = showprofile
1014 1014 self.nplots = nplots
1015 1015
1016 1016 ncolspan = 7
1017 1017 colspan = 6
1018 1018 self.__nsubplots = 2
1019 1019
1020 1020 self.createFigure(id = id,
1021 1021 wintitle = wintitle,
1022 1022 widthplot = self.WIDTH+self.WIDTHPROF,
1023 1023 heightplot = self.HEIGHT+self.HEIGHTPROF,
1024 1024 show=show)
1025 1025
1026 1026 nrow, ncol = self.getSubplots()
1027 1027
1028 1028 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1029 1029
1030 1030
1031 1031 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
1032 1032 xmin=None, xmax=None, ymin=None, ymax=None,
1033 1033 timerange=None,
1034 1034 save=False, figpath='', figfile=None, show=True, ftp=False, wr_period=1,
1035 1035 server=None, folder=None, username=None, password=None,
1036 1036 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1037 1037
1038 1038 if channelList == None:
1039 1039 channelIndexList = dataOut.channelIndexList
1040 1040 channelList = dataOut.channelList
1041 1041 else:
1042 1042 channelIndexList = []
1043 1043 for channel in channelList:
1044 1044 if channel not in dataOut.channelList:
1045 1045 raise ValueError, "Channel %d is not in dataOut.channelList"
1046 1046 channelIndexList.append(dataOut.channelList.index(channel))
1047 1047
1048 1048 if timerange != None:
1049 1049 self.timerange = timerange
1050 1050
1051 1051 tmin = None
1052 1052 tmax = None
1053 1053 x = dataOut.getTimeRange()
1054 1054 y = dataOut.getHeiRange()
1055 1055 factor = dataOut.normFactor
1056 1056 noise = dataOut.noise/factor
1057 1057 noisedB = 10*numpy.log10(noise)
1058 1058
1059 1059 #thisDatetime = dataOut.datatime
1060 1060 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
1061 1061 title = wintitle + " Noise" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
1062 1062 xlabel = ""
1063 1063 ylabel = "Intensity (dB)"
1064 1064
1065 1065 if not self.isConfig:
1066 1066
1067 1067 nplots = 1
1068 1068
1069 1069 self.setup(id=id,
1070 1070 nplots=nplots,
1071 1071 wintitle=wintitle,
1072 1072 showprofile=showprofile,
1073 1073 show=show)
1074 1074
1075 tmin, tmax = self.getTimeLim(x, xmin, xmax)
1075 tmin, tmax = self.getTimeLim(x, xmin, xmax, timezone = dataOut.timezone)
1076 1076 if ymin == None: ymin = numpy.nanmin(noisedB) - 10.0
1077 1077 if ymax == None: ymax = numpy.nanmax(noisedB) + 10.0
1078 1078
1079 1079 self.FTP_WEI = ftp_wei
1080 1080 self.EXP_CODE = exp_code
1081 1081 self.SUB_EXP_CODE = sub_exp_code
1082 1082 self.PLOT_POS = plot_pos
1083 1083
1084 1084
1085 1085 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1086 1086 self.isConfig = True
1087 1087 self.figfile = figfile
1088 1088 self.xdata = numpy.array([])
1089 1089 self.ydata = numpy.array([])
1090 1090
1091 1091 #open file beacon phase
1092 1092 path = '%s%03d' %(self.PREFIX, self.id)
1093 1093 noise_file = os.path.join(path,'%s.txt'%self.name)
1094 1094 self.filename_noise = os.path.join(figpath,noise_file)
1095 1095 self.openfile(self.filename_noise)
1096 1096
1097 1097
1098 1098 #store data beacon phase
1099 1099 self.save_data(self.filename_noise, noisedB, thisDatetime)
1100 1100
1101 1101
1102 1102 self.setWinTitle(title)
1103 1103
1104 1104
1105 1105 title = "Noise %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1106 1106
1107 1107 legendlabels = ["channel %d"%(idchannel+1) for idchannel in channelList]
1108 1108 axes = self.axesList[0]
1109 1109
1110 1110 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1111 1111
1112 1112 if len(self.ydata)==0:
1113 1113 self.ydata = noisedB[channelIndexList].reshape(-1,1)
1114 1114 else:
1115 1115 self.ydata = numpy.hstack((self.ydata, noisedB[channelIndexList].reshape(-1,1)))
1116 1116
1117 1117
1118 1118 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1119 1119 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
1120 1120 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1121 1121 XAxisAsTime=True, grid='both'
1122 1122 )
1123 1123
1124 1124 self.draw()
1125 1125
1126 1126 if x[1] >= self.axesList[0].xmax:
1127 1127 self.counter_imagwr = wr_period
1128 1128 del self.xdata
1129 1129 del self.ydata
1130 1130 self.__isConfig = False
1131 1131
1132 1132 if self.figfile == None:
1133 1133 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
1134 1134 self.figfile = self.getFilename(name = str_datetime)
1135 1135
1136 1136 if figpath != '':
1137 1137 self.counter_imagwr += 1
1138 1138 if (self.counter_imagwr>=wr_period):
1139 1139 # store png plot to local folder
1140 1140 self.saveFigure(figpath, self.figfile)
1141 1141 # store png plot to FTP server according to RT-Web format
1142 1142 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
1143 1143 ftp_filename = os.path.join(figpath, name)
1144 1144 self.saveFigure(figpath, ftp_filename)
1145 1145 self.counter_imagwr = 0
1146 1146
1147 1147
1148 1148 class BeaconPhase(Figure):
1149 1149
1150 1150 __isConfig = None
1151 1151 __nsubplots = None
1152 1152
1153 1153 PREFIX = 'beacon_phase'
1154 1154
1155 1155 def __init__(self):
1156 1156
1157 1157 self.timerange = 24*60*60
1158 1158 self.__isConfig = False
1159 1159 self.__nsubplots = 1
1160 1160 self.counter_imagwr = 0
1161 1161 self.WIDTH = 600
1162 1162 self.HEIGHT = 300
1163 1163 self.WIDTHPROF = 120
1164 1164 self.HEIGHTPROF = 0
1165 1165 self.xdata = None
1166 1166 self.ydata = None
1167 1167
1168 1168 self.PLOT_CODE = 18
1169 1169 self.FTP_WEI = None
1170 1170 self.EXP_CODE = None
1171 1171 self.SUB_EXP_CODE = None
1172 1172 self.PLOT_POS = None
1173 1173
1174 1174 self.filename_phase = None
1175 1175
1176 1176 self.figfile = None
1177 1177
1178 1178 def getSubplots(self):
1179 1179
1180 1180 ncol = 1
1181 1181 nrow = 1
1182 1182
1183 1183 return nrow, ncol
1184 1184
1185 1185 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1186 1186
1187 1187 self.__showprofile = showprofile
1188 1188 self.nplots = nplots
1189 1189
1190 1190 ncolspan = 7
1191 1191 colspan = 6
1192 1192 self.__nsubplots = 2
1193 1193
1194 1194 self.createFigure(id = id,
1195 1195 wintitle = wintitle,
1196 1196 widthplot = self.WIDTH+self.WIDTHPROF,
1197 1197 heightplot = self.HEIGHT+self.HEIGHTPROF,
1198 1198 show=show)
1199 1199
1200 1200 nrow, ncol = self.getSubplots()
1201 1201
1202 1202 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1203 1203
1204 1204 def save_phase(self, filename_phase):
1205 1205 f = open(filename_phase,'w+')
1206 1206 f.write('\n\n')
1207 1207 f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
1208 1208 f.write('DD MM YYYY HH MM SS pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
1209 1209 f.close()
1210 1210
1211 1211 def save_data(self, filename_phase, data, data_datetime):
1212 1212 f=open(filename_phase,'a')
1213 1213 timetuple_data = data_datetime.timetuple()
1214 1214 day = str(timetuple_data.tm_mday)
1215 1215 month = str(timetuple_data.tm_mon)
1216 1216 year = str(timetuple_data.tm_year)
1217 1217 hour = str(timetuple_data.tm_hour)
1218 1218 minute = str(timetuple_data.tm_min)
1219 1219 second = str(timetuple_data.tm_sec)
1220 1220 f.write(day+' '+month+' '+year+' '+hour+' '+minute+' '+second+' '+str(data[0])+' '+str(data[1])+' '+str(data[2])+' '+str(data[3])+'\n')
1221 1221 f.close()
1222 1222
1223 1223
1224 1224 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
1225 1225 xmin=None, xmax=None, ymin=None, ymax=None,
1226 1226 timerange=None,
1227 1227 save=False, figpath='', figfile=None, show=True, ftp=False, wr_period=1,
1228 1228 server=None, folder=None, username=None, password=None,
1229 1229 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1230 1230
1231 1231 if pairsList == None:
1232 1232 pairsIndexList = dataOut.pairsIndexList
1233 1233 else:
1234 1234 pairsIndexList = []
1235 1235 for pair in pairsList:
1236 1236 if pair not in dataOut.pairsList:
1237 1237 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
1238 1238 pairsIndexList.append(dataOut.pairsList.index(pair))
1239 1239
1240 1240 if pairsIndexList == []:
1241 1241 return
1242 1242
1243 1243 # if len(pairsIndexList) > 4:
1244 1244 # pairsIndexList = pairsIndexList[0:4]
1245 1245
1246 1246 if timerange != None:
1247 1247 self.timerange = timerange
1248 1248
1249 1249 tmin = None
1250 1250 tmax = None
1251 1251 x = dataOut.getTimeRange()
1252 1252 y = dataOut.getHeiRange()
1253 1253
1254 1254
1255 1255 #thisDatetime = dataOut.datatime
1256 1256 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
1257 1257 title = wintitle + " Phase of Beacon Signal" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
1258 1258 xlabel = "Local Time"
1259 1259 ylabel = "Phase"
1260 1260
1261 1261 nplots = len(pairsIndexList)
1262 1262 #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
1263 1263 phase_beacon = numpy.zeros(len(pairsIndexList))
1264 1264 for i in range(nplots):
1265 1265 pair = dataOut.pairsList[pairsIndexList[i]]
1266 1266 ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
1267 1267 powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
1268 1268 powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
1269 1269 avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
1270 1270 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
1271 1271
1272 1272 #print "Phase %d%d" %(pair[0], pair[1])
1273 1273 #print phase[dataOut.beacon_heiIndexList]
1274 1274
1275 1275 phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
1276 1276
1277 1277 if not self.__isConfig:
1278 1278
1279 1279 nplots = len(pairsIndexList)
1280 1280
1281 1281 self.setup(id=id,
1282 1282 nplots=nplots,
1283 1283 wintitle=wintitle,
1284 1284 showprofile=showprofile,
1285 1285 show=show)
1286 1286
1287 tmin, tmax = self.getTimeLim(x, xmin, xmax)
1287 tmin, tmax = self.getTimeLim(x, xmin, xmax, timezone = dataOut.timezone)
1288 1288 if ymin == None: ymin = numpy.nanmin(phase_beacon) - 10.0
1289 1289 if ymax == None: ymax = numpy.nanmax(phase_beacon) + 10.0
1290 1290
1291 1291 self.FTP_WEI = ftp_wei
1292 1292 self.EXP_CODE = exp_code
1293 1293 self.SUB_EXP_CODE = sub_exp_code
1294 1294 self.PLOT_POS = plot_pos
1295 1295
1296 1296 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1297 1297 self.__isConfig = True
1298 1298 self.figfile = figfile
1299 1299 self.xdata = numpy.array([])
1300 1300 self.ydata = numpy.array([])
1301 1301
1302 1302 #open file beacon phase
1303 1303 path = '%s%03d' %(self.PREFIX, self.id)
1304 1304 beacon_file = os.path.join(path,'%s.txt'%self.name)
1305 1305 self.filename_phase = os.path.join(figpath,beacon_file)
1306 1306 #self.save_phase(self.filename_phase)
1307 1307
1308 1308
1309 1309 #store data beacon phase
1310 1310 #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
1311 1311
1312 1312 self.setWinTitle(title)
1313 1313
1314 1314
1315 1315 title = "Beacon Signal %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1316 1316
1317 1317 legendlabels = ["pairs %d%d"%(pair[0], pair[1]) for pair in dataOut.pairsList]
1318 1318
1319 1319 axes = self.axesList[0]
1320 1320
1321 1321 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1322 1322
1323 1323 if len(self.ydata)==0:
1324 1324 self.ydata = phase_beacon.reshape(-1,1)
1325 1325 else:
1326 1326 self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
1327 1327
1328 1328
1329 1329 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1330 1330 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
1331 1331 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1332 1332 XAxisAsTime=True, grid='both'
1333 1333 )
1334 1334
1335 1335 self.draw()
1336 1336
1337 1337 if x[1] >= self.axesList[0].xmax:
1338 1338 self.counter_imagwr = wr_period
1339 1339 del self.xdata
1340 1340 del self.ydata
1341 1341 self.__isConfig = False
1342 1342
1343 1343 if self.figfile == None:
1344 1344 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
1345 1345 self.figfile = self.getFilename(name = str_datetime)
1346 1346
1347 1347 if figpath != '':
1348 1348 self.counter_imagwr += 1
1349 1349 if (self.counter_imagwr>=wr_period):
1350 1350 # store png plot to local folder
1351 1351 self.saveFigure(figpath, self.figfile)
1352 1352 # store png plot to FTP server according to RT-Web format
1353 1353 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
1354 1354 ftp_filename = os.path.join(figpath, name)
1355 1355 self.saveFigure(figpath, ftp_filename)
1356 1356 self.counter_imagwr = 0
General Comments 0
You need to be logged in to leave comments. Login now