##// END OF EJS Templates
schain
RSS
Se ploteo el valor maximo del espectro, SpectraHeis
Daniel Valdez -
r336:be49c974ff74
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1308 +1,1308
1 1 import numpy
2 2 import time, datetime, os
3 3 from graphics.figure import *
4 4
5 5 class CrossSpectraPlot(Figure):
6 6
7 7 __isConfig = None
8 8 __nsubplots = None
9 9
10 10 WIDTH = None
11 11 HEIGHT = None
12 12 WIDTHPROF = None
13 13 HEIGHTPROF = None
14 14 PREFIX = 'cspc'
15 15
16 16 def __init__(self):
17 17
18 18 self.__isConfig = False
19 19 self.__nsubplots = 4
20 20
21 21 self.WIDTH = 250
22 22 self.HEIGHT = 250
23 23 self.WIDTHPROF = 0
24 24 self.HEIGHTPROF = 0
25 25
26 26 def getSubplots(self):
27 27
28 28 ncol = 4
29 29 nrow = self.nplots
30 30
31 31 return nrow, ncol
32 32
33 33 def setup(self, idfigure, nplots, wintitle, showprofile=True):
34 34
35 35 self.__showprofile = showprofile
36 36 self.nplots = nplots
37 37
38 38 ncolspan = 1
39 39 colspan = 1
40 40
41 41 self.createFigure(idfigure = idfigure,
42 42 wintitle = wintitle,
43 43 widthplot = self.WIDTH + self.WIDTHPROF,
44 44 heightplot = self.HEIGHT + self.HEIGHTPROF)
45 45
46 46 nrow, ncol = self.getSubplots()
47 47
48 48 counter = 0
49 49 for y in range(nrow):
50 50 for x in range(ncol):
51 51 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
52 52
53 53 counter += 1
54 54
55 55 def run(self, dataOut, idfigure, wintitle="", pairsList=None, showprofile='True',
56 56 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
57 57 save=False, figpath='./', figfile=None,
58 58 power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r'):
59 59
60 60 """
61 61
62 62 Input:
63 63 dataOut :
64 64 idfigure :
65 65 wintitle :
66 66 channelList :
67 67 showProfile :
68 68 xmin : None,
69 69 xmax : None,
70 70 ymin : None,
71 71 ymax : None,
72 72 zmin : None,
73 73 zmax : None
74 74 """
75 75
76 76 if pairsList == None:
77 77 pairsIndexList = dataOut.pairsIndexList
78 78 else:
79 79 pairsIndexList = []
80 80 for pair in pairsList:
81 81 if pair not in dataOut.pairsList:
82 82 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
83 83 pairsIndexList.append(dataOut.pairsList.index(pair))
84 84
85 85 if pairsIndexList == []:
86 86 return
87 87
88 88 if len(pairsIndexList) > 4:
89 89 pairsIndexList = pairsIndexList[0:4]
90 90 factor = dataOut.normFactor
91 91 x = dataOut.getVelRange(1)
92 92 y = dataOut.getHeiRange()
93 93 z = dataOut.data_spc[:,:,:]/factor
94 94 # z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
95 95 avg = numpy.abs(numpy.average(z, axis=1))
96 96 noise = dataOut.getNoise()/factor
97 97
98 98 zdB = 10*numpy.log10(z)
99 99 avgdB = 10*numpy.log10(avg)
100 100 noisedB = 10*numpy.log10(noise)
101 101
102 102
103 103 thisDatetime = dataOut.datatime
104 104 title = "Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
105 105 xlabel = "Velocity (m/s)"
106 106 ylabel = "Range (Km)"
107 107
108 108 if not self.__isConfig:
109 109
110 110 nplots = len(pairsIndexList)
111 111
112 112 self.setup(idfigure=idfigure,
113 113 nplots=nplots,
114 114 wintitle=wintitle,
115 115 showprofile=showprofile)
116 116
117 117 if xmin == None: xmin = numpy.nanmin(x)
118 118 if xmax == None: xmax = numpy.nanmax(x)
119 119 if ymin == None: ymin = numpy.nanmin(y)
120 120 if ymax == None: ymax = numpy.nanmax(y)
121 121 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
122 122 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
123 123
124 124 self.__isConfig = True
125 125
126 126 self.setWinTitle(title)
127 127
128 128 for i in range(self.nplots):
129 129 pair = dataOut.pairsList[pairsIndexList[i]]
130 130
131 131 title = "Channel %d: %4.2fdB" %(pair[0], noisedB[pair[0]])
132 132 zdB = 10.*numpy.log10(dataOut.data_spc[pair[0],:,:]/factor)
133 133 axes0 = self.axesList[i*self.__nsubplots]
134 134 axes0.pcolor(x, y, zdB,
135 135 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
136 136 xlabel=xlabel, ylabel=ylabel, title=title,
137 137 ticksize=9, colormap=power_cmap, cblabel='')
138 138
139 139 title = "Channel %d: %4.2fdB" %(pair[1], noisedB[pair[1]])
140 140 zdB = 10.*numpy.log10(dataOut.data_spc[pair[1],:,:]/factor)
141 141 axes0 = self.axesList[i*self.__nsubplots+1]
142 142 axes0.pcolor(x, y, zdB,
143 143 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
144 144 xlabel=xlabel, ylabel=ylabel, title=title,
145 145 ticksize=9, colormap=power_cmap, cblabel='')
146 146
147 147 coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
148 148 coherence = numpy.abs(coherenceComplex)
149 149 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
150 150 phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
151 151
152 152 title = "Coherence %d%d" %(pair[0], pair[1])
153 153 axes0 = self.axesList[i*self.__nsubplots+2]
154 154 axes0.pcolor(x, y, coherence,
155 155 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
156 156 xlabel=xlabel, ylabel=ylabel, title=title,
157 157 ticksize=9, colormap=coherence_cmap, cblabel='')
158 158
159 159 title = "Phase %d%d" %(pair[0], pair[1])
160 160 axes0 = self.axesList[i*self.__nsubplots+3]
161 161 axes0.pcolor(x, y, phase,
162 162 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
163 163 xlabel=xlabel, ylabel=ylabel, title=title,
164 164 ticksize=9, colormap=phase_cmap, cblabel='')
165 165
166 166
167 167
168 168 self.draw()
169 169
170 170 if save:
171 171 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
172 172 if figfile == None:
173 173 figfile = self.getFilename(name = date)
174 174
175 175 self.saveFigure(figpath, figfile)
176 176
177 177
178 178 class RTIPlot(Figure):
179 179
180 180 __isConfig = None
181 181 __nsubplots = None
182 182
183 183 WIDTHPROF = None
184 184 HEIGHTPROF = None
185 185 PREFIX = 'rti'
186 186
187 187 def __init__(self):
188 188
189 189 self.timerange = 2*60*60
190 190 self.__isConfig = False
191 191 self.__nsubplots = 1
192 192
193 193 self.WIDTH = 800
194 194 self.HEIGHT = 150
195 195 self.WIDTHPROF = 120
196 196 self.HEIGHTPROF = 0
197 197 self.counterftp = 0
198 198
199 199 def getSubplots(self):
200 200
201 201 ncol = 1
202 202 nrow = self.nplots
203 203
204 204 return nrow, ncol
205 205
206 206 def setup(self, idfigure, nplots, wintitle, showprofile=True):
207 207
208 208 self.__showprofile = showprofile
209 209 self.nplots = nplots
210 210
211 211 ncolspan = 1
212 212 colspan = 1
213 213 if showprofile:
214 214 ncolspan = 7
215 215 colspan = 6
216 216 self.__nsubplots = 2
217 217
218 218 self.createFigure(idfigure = idfigure,
219 219 wintitle = wintitle,
220 220 widthplot = self.WIDTH + self.WIDTHPROF,
221 221 heightplot = self.HEIGHT + self.HEIGHTPROF)
222 222
223 223 nrow, ncol = self.getSubplots()
224 224
225 225 counter = 0
226 226 for y in range(nrow):
227 227 for x in range(ncol):
228 228
229 229 if counter >= self.nplots:
230 230 break
231 231
232 232 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
233 233
234 234 if showprofile:
235 235 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
236 236
237 237 counter += 1
238 238
239 239 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
240 240 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
241 241 timerange=None,
242 242 save=False, figpath='./', figfile=None, ftp=False, ftpratio=1):
243 243
244 244 """
245 245
246 246 Input:
247 247 dataOut :
248 248 idfigure :
249 249 wintitle :
250 250 channelList :
251 251 showProfile :
252 252 xmin : None,
253 253 xmax : None,
254 254 ymin : None,
255 255 ymax : None,
256 256 zmin : None,
257 257 zmax : None
258 258 """
259 259
260 260 if channelList == None:
261 261 channelIndexList = dataOut.channelIndexList
262 262 else:
263 263 channelIndexList = []
264 264 for channel in channelList:
265 265 if channel not in dataOut.channelList:
266 266 raise ValueError, "Channel %d is not in dataOut.channelList"
267 267 channelIndexList.append(dataOut.channelList.index(channel))
268 268
269 269 if timerange != None:
270 270 self.timerange = timerange
271 271
272 272 tmin = None
273 273 tmax = None
274 274 factor = dataOut.normFactor
275 275 x = dataOut.getTimeRange()
276 276 y = dataOut.getHeiRange()
277 277
278 278 z = dataOut.data_spc[channelIndexList,:,:]/factor
279 279 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
280 280 avg = numpy.average(z, axis=1)
281 281
282 282 avgdB = 10.*numpy.log10(avg)
283 283
284 284
285 285 thisDatetime = dataOut.datatime
286 286 title = "RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
287 287 xlabel = ""
288 288 ylabel = "Range (Km)"
289 289
290 290 if not self.__isConfig:
291 291
292 292 nplots = len(channelIndexList)
293 293
294 294 self.setup(idfigure=idfigure,
295 295 nplots=nplots,
296 296 wintitle=wintitle,
297 297 showprofile=showprofile)
298 298
299 299 tmin, tmax = self.getTimeLim(x, xmin, xmax)
300 300 if ymin == None: ymin = numpy.nanmin(y)
301 301 if ymax == None: ymax = numpy.nanmax(y)
302 302 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
303 303 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
304 304
305 305 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
306 306 self.__isConfig = True
307 307
308 308
309 309 self.setWinTitle(title)
310 310
311 311 for i in range(self.nplots):
312 312 title = "Channel %d: %s" %(dataOut.channelList[i], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
313 313 axes = self.axesList[i*self.__nsubplots]
314 314 zdB = avgdB[i].reshape((1,-1))
315 315 axes.pcolorbuffer(x, y, zdB,
316 316 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
317 317 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
318 318 ticksize=9, cblabel='', cbsize="1%")
319 319
320 320 if self.__showprofile:
321 321 axes = self.axesList[i*self.__nsubplots +1]
322 322 axes.pline(avgdB[i], y,
323 323 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
324 324 xlabel='dB', ylabel='', title='',
325 325 ytick_visible=False,
326 326 grid='x')
327 327
328 328 self.draw()
329 329
330 330 if save:
331 331
332 332 if figfile == None:
333 333 figfile = self.getFilename(name = self.name)
334 334
335 335 self.saveFigure(figpath, figfile)
336 336
337 337 self.counterftp += 1
338 338 if (ftp and (self.counterftp==ftpratio)):
339 339 figfilename = os.path.join(figpath,figfile)
340 340 self.sendByFTP(figfilename)
341 341 self.counterftp = 0
342 342
343 343 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
344 344 self.__isConfig = False
345 345
346 346 class SpectraPlot(Figure):
347 347
348 348 __isConfig = None
349 349 __nsubplots = None
350 350
351 351 WIDTHPROF = None
352 352 HEIGHTPROF = None
353 353 PREFIX = 'spc'
354 354
355 355 def __init__(self):
356 356
357 357 self.__isConfig = False
358 358 self.__nsubplots = 1
359 359
360 360 self.WIDTH = 230
361 361 self.HEIGHT = 250
362 362 self.WIDTHPROF = 120
363 363 self.HEIGHTPROF = 0
364 364
365 365 def getSubplots(self):
366 366
367 367 ncol = int(numpy.sqrt(self.nplots)+0.9)
368 368 nrow = int(self.nplots*1./ncol + 0.9)
369 369
370 370 return nrow, ncol
371 371
372 372 def setup(self, idfigure, nplots, wintitle, showprofile=True):
373 373
374 374 self.__showprofile = showprofile
375 375 self.nplots = nplots
376 376
377 377 ncolspan = 1
378 378 colspan = 1
379 379 if showprofile:
380 380 ncolspan = 3
381 381 colspan = 2
382 382 self.__nsubplots = 2
383 383
384 384 self.createFigure(idfigure = idfigure,
385 385 wintitle = wintitle,
386 386 widthplot = self.WIDTH + self.WIDTHPROF,
387 387 heightplot = self.HEIGHT + self.HEIGHTPROF)
388 388
389 389 nrow, ncol = self.getSubplots()
390 390
391 391 counter = 0
392 392 for y in range(nrow):
393 393 for x in range(ncol):
394 394
395 395 if counter >= self.nplots:
396 396 break
397 397
398 398 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
399 399
400 400 if showprofile:
401 401 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
402 402
403 403 counter += 1
404 404
405 405 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
406 406 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
407 407 save=False, figpath='./', figfile=None):
408 408
409 409 """
410 410
411 411 Input:
412 412 dataOut :
413 413 idfigure :
414 414 wintitle :
415 415 channelList :
416 416 showProfile :
417 417 xmin : None,
418 418 xmax : None,
419 419 ymin : None,
420 420 ymax : None,
421 421 zmin : None,
422 422 zmax : None
423 423 """
424 424
425 425 if channelList == None:
426 426 channelIndexList = dataOut.channelIndexList
427 427 else:
428 428 channelIndexList = []
429 429 for channel in channelList:
430 430 if channel not in dataOut.channelList:
431 431 raise ValueError, "Channel %d is not in dataOut.channelList"
432 432 channelIndexList.append(dataOut.channelList.index(channel))
433 433 factor = dataOut.normFactor
434 434 x = dataOut.getVelRange(1)
435 435 y = dataOut.getHeiRange()
436 436
437 437 z = dataOut.data_spc[channelIndexList,:,:]/factor
438 438 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
439 439 avg = numpy.average(z, axis=1)
440 440 noise = dataOut.getNoise()/factor
441 441
442 442 zdB = 10*numpy.log10(z)
443 443 avgdB = 10*numpy.log10(avg)
444 444 noisedB = 10*numpy.log10(noise)
445 445
446 446 thisDatetime = dataOut.datatime
447 447 title = "Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
448 448 xlabel = "Velocity (m/s)"
449 449 ylabel = "Range (Km)"
450 450
451 451 if not self.__isConfig:
452 452
453 453 nplots = len(channelIndexList)
454 454
455 455 self.setup(idfigure=idfigure,
456 456 nplots=nplots,
457 457 wintitle=wintitle,
458 458 showprofile=showprofile)
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(avgdB)*0.9
465 465 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
466 466
467 467 self.__isConfig = True
468 468
469 469 self.setWinTitle(title)
470 470
471 471 for i in range(self.nplots):
472 472 title = "Channel %d: %4.2fdB" %(dataOut.channelList[i], noisedB[i])
473 473 axes = self.axesList[i*self.__nsubplots]
474 474 axes.pcolor(x, y, zdB[i,:,:],
475 475 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
476 476 xlabel=xlabel, ylabel=ylabel, title=title,
477 477 ticksize=9, cblabel='')
478 478
479 479 if self.__showprofile:
480 480 axes = self.axesList[i*self.__nsubplots +1]
481 481 axes.pline(avgdB[i], y,
482 482 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
483 483 xlabel='dB', ylabel='', title='',
484 484 ytick_visible=False,
485 485 grid='x')
486 486
487 487 noiseline = numpy.repeat(noisedB[i], len(y))
488 488 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
489 489
490 490 self.draw()
491 491
492 492 if save:
493 493 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
494 494 if figfile == None:
495 495 figfile = self.getFilename(name = date)
496 496
497 497 self.saveFigure(figpath, figfile)
498 498
499 499 class Scope(Figure):
500 500
501 501 __isConfig = None
502 502
503 503 def __init__(self):
504 504
505 505 self.__isConfig = False
506 506 self.WIDTH = 600
507 507 self.HEIGHT = 200
508 508
509 509 def getSubplots(self):
510 510
511 511 nrow = self.nplots
512 512 ncol = 3
513 513 return nrow, ncol
514 514
515 515 def setup(self, idfigure, nplots, wintitle):
516 516
517 517 self.nplots = nplots
518 518
519 519 self.createFigure(idfigure, wintitle)
520 520
521 521 nrow,ncol = self.getSubplots()
522 522 colspan = 3
523 523 rowspan = 1
524 524
525 525 for i in range(nplots):
526 526 self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
527 527
528 528
529 529
530 530 def run(self, dataOut, idfigure, wintitle="", channelList=None,
531 531 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
532 532 figpath='./', figfile=None):
533 533
534 534 """
535 535
536 536 Input:
537 537 dataOut :
538 538 idfigure :
539 539 wintitle :
540 540 channelList :
541 541 xmin : None,
542 542 xmax : None,
543 543 ymin : None,
544 544 ymax : None,
545 545 """
546 546
547 547 if channelList == None:
548 548 channelIndexList = dataOut.channelIndexList
549 549 else:
550 550 channelIndexList = []
551 551 for channel in channelList:
552 552 if channel not in dataOut.channelList:
553 553 raise ValueError, "Channel %d is not in dataOut.channelList"
554 554 channelIndexList.append(dataOut.channelList.index(channel))
555 555
556 556 x = dataOut.heightList
557 557 y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
558 558 y = y.real
559 559
560 560 thisDatetime = dataOut.datatime
561 561 title = "Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
562 562 xlabel = "Range (Km)"
563 563 ylabel = "Intensity"
564 564
565 565 if not self.__isConfig:
566 566 nplots = len(channelIndexList)
567 567
568 568 self.setup(idfigure=idfigure,
569 569 nplots=nplots,
570 570 wintitle=wintitle)
571 571
572 572 if xmin == None: xmin = numpy.nanmin(x)
573 573 if xmax == None: xmax = numpy.nanmax(x)
574 574 if ymin == None: ymin = numpy.nanmin(y)
575 575 if ymax == None: ymax = numpy.nanmax(y)
576 576
577 577 self.__isConfig = True
578 578
579 579 self.setWinTitle(title)
580 580
581 581 for i in range(len(self.axesList)):
582 582 title = "Channel %d" %(i)
583 583 axes = self.axesList[i]
584 584 ychannel = y[i,:]
585 585 axes.pline(x, ychannel,
586 586 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
587 587 xlabel=xlabel, ylabel=ylabel, title=title)
588 588
589 589 self.draw()
590 590
591 591 if save:
592 592 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
593 593 if figfile == None:
594 594 figfile = self.getFilename(name = date)
595 595
596 596 self.saveFigure(figpath, figfile)
597 597
598 598 class ProfilePlot(Figure):
599 599 __isConfig = None
600 600 __nsubplots = None
601 601
602 602 WIDTHPROF = None
603 603 HEIGHTPROF = None
604 604 PREFIX = 'spcprofile'
605 605
606 606 def __init__(self):
607 607 self.__isConfig = False
608 608 self.__nsubplots = 1
609 609
610 610 self.WIDTH = 300
611 611 self.HEIGHT = 500
612 612
613 613 def getSubplots(self):
614 614 ncol = 1
615 615 nrow = 1
616 616
617 617 return nrow, ncol
618 618
619 619 def setup(self, idfigure, nplots, wintitle):
620 620
621 621 self.nplots = nplots
622 622
623 623 ncolspan = 1
624 624 colspan = 1
625 625
626 626 self.createFigure(idfigure = idfigure,
627 627 wintitle = wintitle,
628 628 widthplot = self.WIDTH,
629 629 heightplot = self.HEIGHT)
630 630
631 631 nrow, ncol = self.getSubplots()
632 632
633 633 counter = 0
634 634 for y in range(nrow):
635 635 for x in range(ncol):
636 636 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
637 637
638 638 def run(self, dataOut, idfigure, wintitle="", channelList=None,
639 639 xmin=None, xmax=None, ymin=None, ymax=None,
640 640 save=False, figpath='./', figfile=None):
641 641
642 642 if channelList == None:
643 643 channelIndexList = dataOut.channelIndexList
644 644 channelList = dataOut.channelList
645 645 else:
646 646 channelIndexList = []
647 647 for channel in channelList:
648 648 if channel not in dataOut.channelList:
649 649 raise ValueError, "Channel %d is not in dataOut.channelList"
650 650 channelIndexList.append(dataOut.channelList.index(channel))
651 651
652 652 factor = dataOut.normFactor
653 653 y = dataOut.getHeiRange()
654 654 x = dataOut.data_spc[channelIndexList,:,:]/factor
655 655 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
656 656 avg = numpy.average(x, axis=1)
657 657
658 658 avgdB = 10*numpy.log10(avg)
659 659
660 660 thisDatetime = dataOut.datatime
661 661 title = "Power Profile"
662 662 xlabel = "dB"
663 663 ylabel = "Range (Km)"
664 664
665 665 if not self.__isConfig:
666 666
667 667 nplots = 1
668 668
669 669 self.setup(idfigure=idfigure,
670 670 nplots=nplots,
671 671 wintitle=wintitle)
672 672
673 673 if ymin == None: ymin = numpy.nanmin(y)
674 674 if ymax == None: ymax = numpy.nanmax(y)
675 675 if xmin == None: xmin = numpy.nanmin(avgdB)*0.9
676 676 if xmax == None: xmax = numpy.nanmax(avgdB)*0.9
677 677
678 678 self.__isConfig = True
679 679
680 680 self.setWinTitle(title)
681 681
682 682
683 683 title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
684 684 axes = self.axesList[0]
685 685
686 686 legendlabels = ["channel %d"%x for x in channelList]
687 687 axes.pmultiline(avgdB, y,
688 688 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
689 689 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
690 690 ytick_visible=True, nxticks=5,
691 691 grid='x')
692 692
693 693 self.draw()
694 694
695 695 if save:
696 696 date = thisDatetime.strftime("%Y%m%d")
697 697 if figfile == None:
698 698 figfile = self.getFilename(name = date)
699 699
700 700 self.saveFigure(figpath, figfile)
701 701
702 702 class CoherenceMap(Figure):
703 703 __isConfig = None
704 704 __nsubplots = None
705 705
706 706 WIDTHPROF = None
707 707 HEIGHTPROF = None
708 708 PREFIX = 'cmap'
709 709
710 710 def __init__(self):
711 711 self.timerange = 2*60*60
712 712 self.__isConfig = False
713 713 self.__nsubplots = 1
714 714
715 715 self.WIDTH = 800
716 716 self.HEIGHT = 150
717 717 self.WIDTHPROF = 120
718 718 self.HEIGHTPROF = 0
719 719 self.counterftp = 0
720 720
721 721 def getSubplots(self):
722 722 ncol = 1
723 723 nrow = self.nplots*2
724 724
725 725 return nrow, ncol
726 726
727 727 def setup(self, idfigure, nplots, wintitle, showprofile=True):
728 728 self.__showprofile = showprofile
729 729 self.nplots = nplots
730 730
731 731 ncolspan = 1
732 732 colspan = 1
733 733 if showprofile:
734 734 ncolspan = 7
735 735 colspan = 6
736 736 self.__nsubplots = 2
737 737
738 738 self.createFigure(idfigure = idfigure,
739 739 wintitle = wintitle,
740 740 widthplot = self.WIDTH + self.WIDTHPROF,
741 741 heightplot = self.HEIGHT + self.HEIGHTPROF)
742 742
743 743 nrow, ncol = self.getSubplots()
744 744
745 745 for y in range(nrow):
746 746 for x in range(ncol):
747 747
748 748 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
749 749
750 750 if showprofile:
751 751 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
752 752
753 753 def run(self, dataOut, idfigure, wintitle="", pairsList=None, showprofile='True',
754 754 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
755 755 timerange=None,
756 756 save=False, figpath='./', figfile=None, ftp=False, ftpratio=1,
757 757 coherence_cmap='jet', phase_cmap='RdBu_r'):
758 758
759 759 if pairsList == None:
760 760 pairsIndexList = dataOut.pairsIndexList
761 761 else:
762 762 pairsIndexList = []
763 763 for pair in pairsList:
764 764 if pair not in dataOut.pairsList:
765 765 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
766 766 pairsIndexList.append(dataOut.pairsList.index(pair))
767 767
768 768 if timerange != None:
769 769 self.timerange = timerange
770 770
771 771 if pairsIndexList == []:
772 772 return
773 773
774 774 if len(pairsIndexList) > 4:
775 775 pairsIndexList = pairsIndexList[0:4]
776 776
777 777 tmin = None
778 778 tmax = None
779 779 x = dataOut.getTimeRange()
780 780 y = dataOut.getHeiRange()
781 781
782 782 thisDatetime = dataOut.datatime
783 783 title = "CoherenceMap: %s" %(thisDatetime.strftime("%d-%b-%Y"))
784 784 xlabel = ""
785 785 ylabel = "Range (Km)"
786 786
787 787 if not self.__isConfig:
788 788 nplots = len(pairsIndexList)
789 789 self.setup(idfigure=idfigure,
790 790 nplots=nplots,
791 791 wintitle=wintitle,
792 792 showprofile=showprofile)
793 793
794 794 tmin, tmax = self.getTimeLim(x, xmin, xmax)
795 795 if ymin == None: ymin = numpy.nanmin(y)
796 796 if ymax == None: ymax = numpy.nanmax(y)
797 797
798 798 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
799 799
800 800 self.__isConfig = True
801 801
802 802 self.setWinTitle(title)
803 803
804 804 for i in range(self.nplots):
805 805
806 806 pair = dataOut.pairsList[pairsIndexList[i]]
807 807 coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
808 808 avgcoherenceComplex = numpy.average(coherenceComplex, axis=0)
809 809 coherence = numpy.abs(avgcoherenceComplex)
810 810 # coherence = numpy.abs(coherenceComplex)
811 811 # avg = numpy.average(coherence, axis=0)
812 812
813 813 z = coherence.reshape((1,-1))
814 814
815 815 counter = 0
816 816
817 817 title = "Coherence %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
818 818 axes = self.axesList[i*self.__nsubplots*2]
819 819 axes.pcolorbuffer(x, y, z,
820 820 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
821 821 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
822 822 ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
823 823
824 824 if self.__showprofile:
825 825 counter += 1
826 826 axes = self.axesList[i*self.__nsubplots*2 + counter]
827 827 axes.pline(coherence, y,
828 828 xmin=0, xmax=1, ymin=ymin, ymax=ymax,
829 829 xlabel='', ylabel='', title='', ticksize=7,
830 830 ytick_visible=False, nxticks=5,
831 831 grid='x')
832 832
833 833 counter += 1
834 834 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
835 835 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
836 836 # avg = numpy.average(phase, axis=0)
837 837 z = phase.reshape((1,-1))
838 838
839 839 title = "Phase %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
840 840 axes = self.axesList[i*self.__nsubplots*2 + counter]
841 841 axes.pcolorbuffer(x, y, z,
842 842 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
843 843 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
844 844 ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
845 845
846 846 if self.__showprofile:
847 847 counter += 1
848 848 axes = self.axesList[i*self.__nsubplots*2 + counter]
849 849 axes.pline(phase, y,
850 850 xmin=-180, xmax=180, ymin=ymin, ymax=ymax,
851 851 xlabel='', ylabel='', title='', ticksize=7,
852 852 ytick_visible=False, nxticks=4,
853 853 grid='x')
854 854
855 855 self.draw()
856 856
857 857 if save:
858 858
859 859 if figfile == None:
860 860 figfile = self.getFilename(name = self.name)
861 861
862 862 self.saveFigure(figpath, figfile)
863 863
864 864 self.counterftp += 1
865 865 if (ftp and (self.counterftp==ftpratio)):
866 866 figfilename = os.path.join(figpath,figfile)
867 867 self.sendByFTP(figfilename)
868 868 self.counterftp = 0
869 869
870 870 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
871 871 self.__isConfig = False
872 872
873 873 class RTIfromNoise(Figure):
874 874
875 875 __isConfig = None
876 876 __nsubplots = None
877 877
878 878 PREFIX = 'rtinoise'
879 879
880 880 def __init__(self):
881 881
882 882 self.timerange = 24*60*60
883 883 self.__isConfig = False
884 884 self.__nsubplots = 1
885 885
886 886 self.WIDTH = 820
887 887 self.HEIGHT = 200
888 888 self.WIDTHPROF = 120
889 889 self.HEIGHTPROF = 0
890 890 self.xdata = None
891 891 self.ydata = None
892 892
893 893 def getSubplots(self):
894 894
895 895 ncol = 1
896 896 nrow = 1
897 897
898 898 return nrow, ncol
899 899
900 900 def setup(self, idfigure, nplots, wintitle, showprofile=True):
901 901
902 902 self.__showprofile = showprofile
903 903 self.nplots = nplots
904 904
905 905 ncolspan = 7
906 906 colspan = 6
907 907 self.__nsubplots = 2
908 908
909 909 self.createFigure(idfigure = idfigure,
910 910 wintitle = wintitle,
911 911 widthplot = self.WIDTH+self.WIDTHPROF,
912 912 heightplot = self.HEIGHT+self.HEIGHTPROF)
913 913
914 914 nrow, ncol = self.getSubplots()
915 915
916 916 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
917 917
918 918
919 919 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
920 920 xmin=None, xmax=None, ymin=None, ymax=None,
921 921 timerange=None,
922 922 save=False, figpath='./', figfile=None):
923 923
924 924 if channelList == None:
925 925 channelIndexList = dataOut.channelIndexList
926 926 channelList = dataOut.channelList
927 927 else:
928 928 channelIndexList = []
929 929 for channel in channelList:
930 930 if channel not in dataOut.channelList:
931 931 raise ValueError, "Channel %d is not in dataOut.channelList"
932 932 channelIndexList.append(dataOut.channelList.index(channel))
933 933
934 934 if timerange != None:
935 935 self.timerange = timerange
936 936
937 937 tmin = None
938 938 tmax = None
939 939 x = dataOut.getTimeRange()
940 940 y = dataOut.getHeiRange()
941 941 factor = dataOut.normFactor
942 942 noise = dataOut.getNoise()/factor
943 943 noisedB = 10*numpy.log10(noise)
944 944
945 945 thisDatetime = dataOut.datatime
946 946 title = "RTI Noise: %s" %(thisDatetime.strftime("%d-%b-%Y"))
947 947 xlabel = ""
948 948 ylabel = "Range (Km)"
949 949
950 950 if not self.__isConfig:
951 951
952 952 nplots = 1
953 953
954 954 self.setup(idfigure=idfigure,
955 955 nplots=nplots,
956 956 wintitle=wintitle,
957 957 showprofile=showprofile)
958 958
959 959 tmin, tmax = self.getTimeLim(x, xmin, xmax)
960 960 if ymin == None: ymin = numpy.nanmin(noisedB)
961 961 if ymax == None: ymax = numpy.nanmax(noisedB)
962 962
963 963 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
964 964 self.__isConfig = True
965 965
966 966 self.xdata = numpy.array([])
967 967 self.ydata = numpy.array([])
968 968
969 969 self.setWinTitle(title)
970 970
971 971
972 972 title = "RTI Noise %s" %(thisDatetime.strftime("%d-%b-%Y"))
973 973
974 974 legendlabels = ["channel %d"%idchannel for idchannel in channelList]
975 975 axes = self.axesList[0]
976 976
977 977 self.xdata = numpy.hstack((self.xdata, x[0:1]))
978 978
979 979 if len(self.ydata)==0:
980 980 self.ydata = noisedB[channelIndexList].reshape(-1,1)
981 981 else:
982 982 self.ydata = numpy.hstack((self.ydata, noisedB[channelIndexList].reshape(-1,1)))
983 983
984 984
985 985 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
986 986 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
987 987 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
988 988 XAxisAsTime=True
989 989 )
990 990
991 991 self.draw()
992 992
993 993 if save:
994 994
995 995 if figfile == None:
996 996 figfile = self.getFilename(name = self.name)
997 997
998 998 self.saveFigure(figpath, figfile)
999 999
1000 1000 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
1001 1001 self.__isConfig = False
1002 1002 del self.xdata
1003 1003 del self.ydata
1004 1004
1005 1005
1006 1006 class SpectraHeisScope(Figure):
1007 1007
1008 1008
1009 1009 __isConfig = None
1010 1010 __nsubplots = None
1011 1011
1012 1012 WIDTHPROF = None
1013 1013 HEIGHTPROF = None
1014 1014 PREFIX = 'spc'
1015 1015
1016 1016 def __init__(self):
1017 1017
1018 1018 self.__isConfig = False
1019 1019 self.__nsubplots = 1
1020 1020
1021 1021 self.WIDTH = 230
1022 1022 self.HEIGHT = 250
1023 1023 self.WIDTHPROF = 120
1024 1024 self.HEIGHTPROF = 0
1025 1025
1026 1026 def getSubplots(self):
1027 1027
1028 1028 ncol = int(numpy.sqrt(self.nplots)+0.9)
1029 1029 nrow = int(self.nplots*1./ncol + 0.9)
1030 1030
1031 1031 return nrow, ncol
1032 1032
1033 1033 def setup(self, idfigure, nplots, wintitle):
1034 1034
1035 1035 showprofile = False
1036 1036 self.__showprofile = showprofile
1037 1037 self.nplots = nplots
1038 1038
1039 1039 ncolspan = 1
1040 1040 colspan = 1
1041 1041 if showprofile:
1042 1042 ncolspan = 3
1043 1043 colspan = 2
1044 1044 self.__nsubplots = 2
1045 1045
1046 1046 self.createFigure(idfigure = idfigure,
1047 1047 wintitle = wintitle,
1048 1048 widthplot = self.WIDTH + self.WIDTHPROF,
1049 1049 heightplot = self.HEIGHT + self.HEIGHTPROF)
1050 1050
1051 1051 nrow, ncol = self.getSubplots()
1052 1052
1053 1053 counter = 0
1054 1054 for y in range(nrow):
1055 1055 for x in range(ncol):
1056 1056
1057 1057 if counter >= self.nplots:
1058 1058 break
1059 1059
1060 1060 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
1061 1061
1062 1062 if showprofile:
1063 1063 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
1064 1064
1065 1065 counter += 1
1066 1066
1067 1067 # __isConfig = None
1068 1068 # def __init__(self):
1069 1069 #
1070 1070 # self.__isConfig = False
1071 1071 # self.WIDTH = 600
1072 1072 # self.HEIGHT = 200
1073 1073 #
1074 1074 # def getSubplots(self):
1075 1075 #
1076 1076 # nrow = self.nplots
1077 1077 # ncol = 3
1078 1078 # return nrow, ncol
1079 1079 #
1080 1080 # def setup(self, idfigure, nplots, wintitle):
1081 1081 #
1082 1082 # self.nplots = nplots
1083 1083 #
1084 1084 # self.createFigure(idfigure, wintitle)
1085 1085 #
1086 1086 # nrow,ncol = self.getSubplots()
1087 1087 # colspan = 3
1088 1088 # rowspan = 1
1089 1089 #
1090 1090 # for i in range(nplots):
1091 1091 # self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
1092 1092
1093 1093 def run(self, dataOut, idfigure, wintitle="", channelList=None,
1094 1094 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
1095 1095 figpath='./', figfile=None):
1096 1096
1097 1097 """
1098 1098
1099 1099 Input:
1100 1100 dataOut :
1101 1101 idfigure :
1102 1102 wintitle :
1103 1103 channelList :
1104 1104 xmin : None,
1105 1105 xmax : None,
1106 1106 ymin : None,
1107 1107 ymax : None,
1108 1108 """
1109 1109
1110 1110 if channelList == None:
1111 1111 channelIndexList = dataOut.channelIndexList
1112 1112 else:
1113 1113 channelIndexList = []
1114 1114 for channel in channelList:
1115 1115 if channel not in dataOut.channelList:
1116 1116 raise ValueError, "Channel %d is not in dataOut.channelList"
1117 1117 channelIndexList.append(dataOut.channelList.index(channel))
1118 1118
1119 1119 # x = dataOut.heightList
1120 1120 c = 3E8
1121 1121 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1122 1122 #deberia cambiar para el caso de 1Mhz y 100KHz
1123 1123 x = numpy.arange(-1*dataOut.nHeights/2.,dataOut.nHeights/2.)*(c/(2*deltaHeight*dataOut.nHeights*1000))
1124 1124 x= x/(10000.0)
1125 1125 # y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
1126 1126 # y = y.real
1127 1127 datadB = 10.*numpy.log10(dataOut.data_spc)
1128 1128 y = datadB
1129 1129
1130 1130 thisDatetime = dataOut.datatime
1131 1131 title = "Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
1132 1132 xlabel = "Frequency"
1133 1133 ylabel = "Intensity (dB)"
1134 1134
1135 1135 if not self.__isConfig:
1136 1136 nplots = len(channelIndexList)
1137 1137
1138 1138 self.setup(idfigure=idfigure,
1139 1139 nplots=nplots,
1140 1140 wintitle=wintitle)
1141 1141
1142 1142 if xmin == None: xmin = numpy.nanmin(x)
1143 1143 if xmax == None: xmax = numpy.nanmax(x)
1144 1144 if ymin == None: ymin = numpy.nanmin(y)
1145 1145 if ymax == None: ymax = numpy.nanmax(y)
1146 1146
1147 1147 self.__isConfig = True
1148 1148
1149 1149 self.setWinTitle(title)
1150 1150
1151 1151 for i in range(len(self.axesList)):
1152 title = "Channel %d" %(i)
1153 axes = self.axesList[i]
1154 1152 ychannel = y[i,:]
1153 title = "Channel %d - peak:%.2f" %(i,numpy.max(ychannel))
1154 axes = self.axesList[i]
1155 1155 axes.pline(x, ychannel,
1156 1156 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
1157 1157 xlabel=xlabel, ylabel=ylabel, title=title)
1158 1158
1159 1159 self.draw()
1160 1160
1161 1161 if save:
1162 1162 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
1163 1163 if figfile == None:
1164 1164 figfile = self.getFilename(name = date)
1165 1165
1166 1166 self.saveFigure(figpath, figfile)
1167 1167
1168 1168
1169 1169 class RTIfromSpectraHeis(Figure):
1170 1170
1171 1171 __isConfig = None
1172 1172 __nsubplots = None
1173 1173
1174 1174 PREFIX = 'rtinoise'
1175 1175
1176 1176 def __init__(self):
1177 1177
1178 1178 self.timerange = 24*60*60
1179 1179 self.__isConfig = False
1180 1180 self.__nsubplots = 1
1181 1181
1182 1182 self.WIDTH = 820
1183 1183 self.HEIGHT = 200
1184 1184 self.WIDTHPROF = 120
1185 1185 self.HEIGHTPROF = 0
1186 1186 self.xdata = None
1187 1187 self.ydata = None
1188 1188
1189 1189 def getSubplots(self):
1190 1190
1191 1191 ncol = 1
1192 1192 nrow = 1
1193 1193
1194 1194 return nrow, ncol
1195 1195
1196 1196 def setup(self, idfigure, nplots, wintitle, showprofile=True):
1197 1197
1198 1198 self.__showprofile = showprofile
1199 1199 self.nplots = nplots
1200 1200
1201 1201 ncolspan = 7
1202 1202 colspan = 6
1203 1203 self.__nsubplots = 2
1204 1204
1205 1205 self.createFigure(idfigure = idfigure,
1206 1206 wintitle = wintitle,
1207 1207 widthplot = self.WIDTH+self.WIDTHPROF,
1208 1208 heightplot = self.HEIGHT+self.HEIGHTPROF)
1209 1209
1210 1210 nrow, ncol = self.getSubplots()
1211 1211
1212 1212 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1213 1213
1214 1214
1215 1215 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
1216 1216 xmin=None, xmax=None, ymin=None, ymax=None,
1217 1217 timerange=None,
1218 1218 save=False, figpath='./', figfile=None):
1219 1219
1220 1220 if channelList == None:
1221 1221 channelIndexList = dataOut.channelIndexList
1222 1222 channelList = dataOut.channelList
1223 1223 else:
1224 1224 channelIndexList = []
1225 1225 for channel in channelList:
1226 1226 if channel not in dataOut.channelList:
1227 1227 raise ValueError, "Channel %d is not in dataOut.channelList"
1228 1228 channelIndexList.append(dataOut.channelList.index(channel))
1229 1229
1230 1230 if timerange != None:
1231 1231 self.timerange = timerange
1232 1232
1233 1233 tmin = None
1234 1234 tmax = None
1235 1235 x = dataOut.getTimeRange()
1236 1236 y = dataOut.getHeiRange()
1237 1237
1238 1238 factor = 1
1239 1239 data = dataOut.data_spc/factor
1240 1240 data = numpy.average(data,axis=1)
1241 1241 datadB = 10*numpy.log10(data)
1242 1242
1243 1243 # factor = dataOut.normFactor
1244 1244 # noise = dataOut.getNoise()/factor
1245 1245 # noisedB = 10*numpy.log10(noise)
1246 1246
1247 1247 thisDatetime = dataOut.datatime
1248 1248 title = "RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
1249 1249 xlabel = "Local Time"
1250 1250 ylabel = "Intensity (dB)"
1251 1251
1252 1252 if not self.__isConfig:
1253 1253
1254 1254 nplots = 1
1255 1255
1256 1256 self.setup(idfigure=idfigure,
1257 1257 nplots=nplots,
1258 1258 wintitle=wintitle,
1259 1259 showprofile=showprofile)
1260 1260
1261 1261 tmin, tmax = self.getTimeLim(x, xmin, xmax)
1262 1262 if ymin == None: ymin = numpy.nanmin(datadB)
1263 1263 if ymax == None: ymax = numpy.nanmax(datadB)
1264 1264
1265 1265 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1266 1266 self.__isConfig = True
1267 1267
1268 1268 self.xdata = numpy.array([])
1269 1269 self.ydata = numpy.array([])
1270 1270
1271 1271 self.setWinTitle(title)
1272 1272
1273 1273
1274 1274 title = "RTI %s" %(thisDatetime.strftime("%d-%b-%Y"))
1275 1275
1276 1276 legendlabels = ["channel %d"%idchannel for idchannel in channelList]
1277 1277 axes = self.axesList[0]
1278 1278
1279 1279 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1280 1280
1281 1281 if len(self.ydata)==0:
1282 1282 self.ydata = datadB[channelIndexList].reshape(-1,1)
1283 1283 else:
1284 1284 self.ydata = numpy.hstack((self.ydata, datadB[channelIndexList].reshape(-1,1)))
1285 1285
1286 1286
1287 1287 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1288 1288 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
1289 1289 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1290 1290 XAxisAsTime=True
1291 1291 )
1292 1292
1293 1293 self.draw()
1294 1294
1295 1295 if save:
1296 1296
1297 1297 if figfile == None:
1298 1298 figfile = self.getFilename(name = self.name)
1299 1299
1300 1300 self.saveFigure(figpath, figfile)
1301 1301
1302 1302 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
1303 1303 self.__isConfig = False
1304 1304 del self.xdata
1305 1305 del self.ydata
1306 1306
1307 1307
1308 1308 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now