##// END OF EJS Templates
schain
RSS
PPI Plot fixed to clockwise
rflores -
r1453:4e2472cf7118
parent child
Show More
Side by Side Unified
Context file:
r1453:4e2472cf7118 Loading diff...:

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

Show file before | Show file after | Hide comments
@@ -1,1788 +1,1790
1 1 import os
2 2 import datetime
3 3 import numpy
4 4 from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter
5 5
6 6 from schainpy.model.graphics.jroplot_base import Plot, plt
7 7 from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
8 8 from schainpy.utils import log
9 9 # libreria wradlib
10 10 import wradlib as wrl
11 11
12 12 EARTH_RADIUS = 6.3710e3
13 13
14 14
15 15 def ll2xy(lat1, lon1, lat2, lon2):
16 16
17 17 p = 0.017453292519943295
18 18 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
19 19 numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
20 20 r = 12742 * numpy.arcsin(numpy.sqrt(a))
21 21 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
22 22 * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
23 23 theta = -theta + numpy.pi/2
24 24 return r*numpy.cos(theta), r*numpy.sin(theta)
25 25
26 26
27 27 def km2deg(km):
28 28 '''
29 29 Convert distance in km to degrees
30 30 '''
31 31
32 32 return numpy.rad2deg(km/EARTH_RADIUS)
33 33
34 34
35 35
36 36 class SpectralMomentsPlot(SpectraPlot):
37 37 '''
38 38 Plot for Spectral Moments
39 39 '''
40 40 CODE = 'spc_moments'
41 41 # colormap = 'jet'
42 42 # plot_type = 'pcolor'
43 43
44 44 class DobleGaussianPlot(SpectraPlot):
45 45 '''
46 46 Plot for Double Gaussian Plot
47 47 '''
48 48 CODE = 'gaussian_fit'
49 49 # colormap = 'jet'
50 50 # plot_type = 'pcolor'
51 51
52 52 class DoubleGaussianSpectraCutPlot(SpectraCutPlot):
53 53 '''
54 54 Plot SpectraCut with Double Gaussian Fit
55 55 '''
56 56 CODE = 'cut_gaussian_fit'
57 57
58 58 class SnrPlot(RTIPlot):
59 59 '''
60 60 Plot for SNR Data
61 61 '''
62 62
63 63 CODE = 'snr'
64 64 colormap = 'jet'
65 65
66 66 def update(self, dataOut):
67 67
68 68 data = {
69 69 'snr': 10*numpy.log10(dataOut.data_snr)
70 70 }
71 71
72 72 return data, {}
73 73
74 74 class DopplerPlot(RTIPlot):
75 75 '''
76 76 Plot for DOPPLER Data (1st moment)
77 77 '''
78 78
79 79 CODE = 'dop'
80 80 colormap = 'jet'
81 81
82 82 def update(self, dataOut):
83 83
84 84 data = {
85 85 'dop': 10*numpy.log10(dataOut.data_dop)
86 86 }
87 87
88 88 return data, {}
89 89
90 90 class PowerPlot(RTIPlot):
91 91 '''
92 92 Plot for Power Data (0 moment)
93 93 '''
94 94
95 95 CODE = 'pow'
96 96 colormap = 'jet'
97 97
98 98 def update(self, dataOut):
99 99 data = {
100 100 'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor)
101 101 }
102 102 return data, {}
103 103
104 104 class SpectralWidthPlot(RTIPlot):
105 105 '''
106 106 Plot for Spectral Width Data (2nd moment)
107 107 '''
108 108
109 109 CODE = 'width'
110 110 colormap = 'jet'
111 111
112 112 def update(self, dataOut):
113 113
114 114 data = {
115 115 'width': dataOut.data_width
116 116 }
117 117
118 118 return data, {}
119 119
120 120 class SkyMapPlot(Plot):
121 121 '''
122 122 Plot for meteors detection data
123 123 '''
124 124
125 125 CODE = 'param'
126 126
127 127 def setup(self):
128 128
129 129 self.ncols = 1
130 130 self.nrows = 1
131 131 self.width = 7.2
132 132 self.height = 7.2
133 133 self.nplots = 1
134 134 self.xlabel = 'Zonal Zenith Angle (deg)'
135 135 self.ylabel = 'Meridional Zenith Angle (deg)'
136 136 self.polar = True
137 137 self.ymin = -180
138 138 self.ymax = 180
139 139 self.colorbar = False
140 140
141 141 def plot(self):
142 142
143 143 arrayParameters = numpy.concatenate(self.data['param'])
144 144 error = arrayParameters[:, -1]
145 145 indValid = numpy.where(error == 0)[0]
146 146 finalMeteor = arrayParameters[indValid, :]
147 147 finalAzimuth = finalMeteor[:, 3]
148 148 finalZenith = finalMeteor[:, 4]
149 149
150 150 x = finalAzimuth * numpy.pi / 180
151 151 y = finalZenith
152 152
153 153 ax = self.axes[0]
154 154
155 155 if ax.firsttime:
156 156 ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
157 157 else:
158 158 ax.plot.set_data(x, y)
159 159
160 160 dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
161 161 dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
162 162 title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
163 163 dt2,
164 164 len(x))
165 165 self.titles[0] = title
166 166
167 167
168 168 class GenericRTIPlot(Plot):
169 169 '''
170 170 Plot for data_xxxx object
171 171 '''
172 172
173 173 CODE = 'param'
174 174 colormap = 'viridis'
175 175 plot_type = 'pcolorbuffer'
176 176
177 177 def setup(self):
178 178 self.xaxis = 'time'
179 179 self.ncols = 1
180 180 self.nrows = self.data.shape('param')[0]
181 181 self.nplots = self.nrows
182 182 self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
183 183
184 184 if not self.xlabel:
185 185 self.xlabel = 'Time'
186 186
187 187 self.ylabel = 'Range [km]'
188 188 if not self.titles:
189 189 self.titles = ['Param {}'.format(x) for x in range(self.nrows)]
190 190
191 191 def update(self, dataOut):
192 192
193 193 data = {
194 194 'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)
195 195 }
196 196
197 197 meta = {}
198 198
199 199 return data, meta
200 200
201 201 def plot(self):
202 202 # self.data.normalize_heights()
203 203 self.x = self.data.times
204 204 self.y = self.data.yrange
205 205 self.z = self.data['param']
206 206 self.z = 10*numpy.log10(self.z)
207 207 self.z = numpy.ma.masked_invalid(self.z)
208 208
209 209 if self.decimation is None:
210 210 x, y, z = self.fill_gaps(self.x, self.y, self.z)
211 211 else:
212 212 x, y, z = self.fill_gaps(*self.decimate())
213 213
214 214 for n, ax in enumerate(self.axes):
215 215
216 216 self.zmax = self.zmax if self.zmax is not None else numpy.max(
217 217 self.z[n])
218 218 self.zmin = self.zmin if self.zmin is not None else numpy.min(
219 219 self.z[n])
220 220
221 221 if ax.firsttime:
222 222 if self.zlimits is not None:
223 223 self.zmin, self.zmax = self.zlimits[n]
224 224
225 225 ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
226 226 vmin=self.zmin,
227 227 vmax=self.zmax,
228 228 cmap=self.cmaps[n]
229 229 )
230 230 else:
231 231 if self.zlimits is not None:
232 232 self.zmin, self.zmax = self.zlimits[n]
233 233 ax.collections.remove(ax.collections[0])
234 234 ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
235 235 vmin=self.zmin,
236 236 vmax=self.zmax,
237 237 cmap=self.cmaps[n]
238 238 )
239 239
240 240
241 241 class PolarMapPlot(Plot):
242 242 '''
243 243 Plot for weather radar
244 244 '''
245 245
246 246 CODE = 'param'
247 247 colormap = 'seismic'
248 248
249 249 def setup(self):
250 250 self.ncols = 1
251 251 self.nrows = 1
252 252 self.width = 9
253 253 self.height = 8
254 254 self.mode = self.data.meta['mode']
255 255 if self.channels is not None:
256 256 self.nplots = len(self.channels)
257 257 self.nrows = len(self.channels)
258 258 else:
259 259 self.nplots = self.data.shape(self.CODE)[0]
260 260 self.nrows = self.nplots
261 261 self.channels = list(range(self.nplots))
262 262 if self.mode == 'E':
263 263 self.xlabel = 'Longitude'
264 264 self.ylabel = 'Latitude'
265 265 else:
266 266 self.xlabel = 'Range (km)'
267 267 self.ylabel = 'Height (km)'
268 268 self.bgcolor = 'white'
269 269 self.cb_labels = self.data.meta['units']
270 270 self.lat = self.data.meta['latitude']
271 271 self.lon = self.data.meta['longitude']
272 272 self.xmin, self.xmax = float(
273 273 km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
274 274 self.ymin, self.ymax = float(
275 275 km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
276 276 # self.polar = True
277 277
278 278 def plot(self):
279 279
280 280 for n, ax in enumerate(self.axes):
281 281 data = self.data['param'][self.channels[n]]
282 282
283 283 zeniths = numpy.linspace(
284 284 0, self.data.meta['max_range'], data.shape[1])
285 285 if self.mode == 'E':
286 286 azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
287 287 r, theta = numpy.meshgrid(zeniths, azimuths)
288 288 x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
289 289 theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
290 290 x = km2deg(x) + self.lon
291 291 y = km2deg(y) + self.lat
292 292 else:
293 293 azimuths = numpy.radians(self.data.yrange)
294 294 r, theta = numpy.meshgrid(zeniths, azimuths)
295 295 x, y = r*numpy.cos(theta), r*numpy.sin(theta)
296 296 self.y = zeniths
297 297
298 298 if ax.firsttime:
299 299 if self.zlimits is not None:
300 300 self.zmin, self.zmax = self.zlimits[n]
301 301 ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
302 302 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
303 303 vmin=self.zmin,
304 304 vmax=self.zmax,
305 305 cmap=self.cmaps[n])
306 306 else:
307 307 if self.zlimits is not None:
308 308 self.zmin, self.zmax = self.zlimits[n]
309 309 ax.collections.remove(ax.collections[0])
310 310 ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
311 311 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
312 312 vmin=self.zmin,
313 313 vmax=self.zmax,
314 314 cmap=self.cmaps[n])
315 315
316 316 if self.mode == 'A':
317 317 continue
318 318
319 319 # plot district names
320 320 f = open('/data/workspace/schain_scripts/distrito.csv')
321 321 for line in f:
322 322 label, lon, lat = [s.strip() for s in line.split(',') if s]
323 323 lat = float(lat)
324 324 lon = float(lon)
325 325 # ax.plot(lon, lat, '.b', ms=2)
326 326 ax.text(lon, lat, label.decode('utf8'), ha='center',
327 327 va='bottom', size='8', color='black')
328 328
329 329 # plot limites
330 330 limites = []
331 331 tmp = []
332 332 for line in open('/data/workspace/schain_scripts/lima.csv'):
333 333 if '#' in line:
334 334 if tmp:
335 335 limites.append(tmp)
336 336 tmp = []
337 337 continue
338 338 values = line.strip().split(',')
339 339 tmp.append((float(values[0]), float(values[1])))
340 340 for points in limites:
341 341 ax.add_patch(
342 342 Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
343 343
344 344 # plot Cuencas
345 345 for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
346 346 f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
347 347 values = [line.strip().split(',') for line in f]
348 348 points = [(float(s[0]), float(s[1])) for s in values]
349 349 ax.add_patch(Polygon(points, ec='b', fc='none'))
350 350
351 351 # plot grid
352 352 for r in (15, 30, 45, 60):
353 353 ax.add_artist(plt.Circle((self.lon, self.lat),
354 354 km2deg(r), color='0.6', fill=False, lw=0.2))
355 355 ax.text(
356 356 self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
357 357 self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
358 358 '{}km'.format(r),
359 359 ha='center', va='bottom', size='8', color='0.6', weight='heavy')
360 360
361 361 if self.mode == 'E':
362 362 title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
363 363 label = 'E{:02d}'.format(int(self.data.meta['elevation']))
364 364 else:
365 365 title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
366 366 label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
367 367
368 368 self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
369 369 self.titles = ['{} {}'.format(
370 370 self.data.parameters[x], title) for x in self.channels]
371 371
372 372 class WeatherPlot(Plot):
373 373 CODE = 'weather'
374 374 plot_name = 'weather'
375 375 plot_type = 'ppistyle'
376 376 buffering = False
377 377
378 378 def setup(self):
379 379 self.ncols = 1
380 380 self.nrows = 1
381 381 self.width =8
382 382 self.height =8
383 383 self.nplots= 1
384 384 self.ylabel= 'Range [Km]'
385 385 self.titles= ['Weather']
386 386 self.colorbar=False
387 387 self.ini =0
388 388 self.len_azi =0
389 389 self.buffer_ini = None
390 390 self.buffer_azi = None
391 391 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
392 392 self.flag =0
393 393 self.indicador= 0
394 394 self.last_data_azi = None
395 395 self.val_mean = None
396 396
397 397 def update(self, dataOut):
398 398
399 399 data = {}
400 400 meta = {}
401 401 if hasattr(dataOut, 'dataPP_POWER'):
402 402 factor = 1
403 403 if hasattr(dataOut, 'nFFTPoints'):
404 404 factor = dataOut.normFactor
405 405 #print("DIME EL SHAPE PORFAVOR",dataOut.data_360.shape)
406 406 data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
407 407 data['azi'] = dataOut.data_azi
408 408 data['ele'] = dataOut.data_ele
409 409 return data, meta
410 410
411 411 def get2List(self,angulos):
412 412 list1=[]
413 413 list2=[]
414 414 for i in reversed(range(len(angulos))):
415 415 diff_ = angulos[i]-angulos[i-1]
416 416 if diff_ >1.5:
417 417 list1.append(i-1)
418 418 list2.append(diff_)
419 419 return list(reversed(list1)),list(reversed(list2))
420 420
421 421 def fixData360(self,list_,ang_):
422 422 if list_[0]==-1:
423 423 vec = numpy.where(ang_<ang_[0])
424 424 ang_[vec] = ang_[vec]+360
425 425 return ang_
426 426 return ang_
427 427
428 428 def fixData360HL(self,angulos):
429 429 vec = numpy.where(angulos>=360)
430 430 angulos[vec]=angulos[vec]-360
431 431 return angulos
432 432
433 433 def search_pos(self,pos,list_):
434 434 for i in range(len(list_)):
435 435 if pos == list_[i]:
436 436 return True,i
437 437 i=None
438 438 return False,i
439 439
440 440 def fixDataComp(self,ang_,list1_,list2_):
441 441 size = len(ang_)
442 442 size2 = 0
443 443 for i in range(len(list2_)):
444 444 size2=size2+round(list2_[i])-1
445 445 new_size= size+size2
446 446 ang_new = numpy.zeros(new_size)
447 447 ang_new2 = numpy.zeros(new_size)
448 448
449 449 tmp = 0
450 450 c = 0
451 451 for i in range(len(ang_)):
452 452 ang_new[tmp +c] = ang_[i]
453 453 ang_new2[tmp+c] = ang_[i]
454 454 condition , value = self.search_pos(i,list1_)
455 455 if condition:
456 456 pos = tmp + c + 1
457 457 for k in range(round(list2_[value])-1):
458 458 ang_new[pos+k] = ang_new[pos+k-1]+1
459 459 ang_new2[pos+k] = numpy.nan
460 460 tmp = pos +k
461 461 c = 0
462 462 c=c+1
463 463 return ang_new,ang_new2
464 464
465 465 def globalCheckPED(self,angulos):
466 466 l1,l2 = self.get2List(angulos)
467 467 if len(l1)>0:
468 468 angulos2 = self.fixData360(list_=l1,ang_=angulos)
469 469 l1,l2 = self.get2List(angulos2)
470 470
471 471 ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2)
472 472 ang1_ = self.fixData360HL(ang1_)
473 473 ang2_ = self.fixData360HL(ang2_)
474 474 else:
475 475 ang1_= angulos
476 476 ang2_= angulos
477 477 return ang1_,ang2_
478 478
479 479 def analizeDATA(self,data_azi):
480 480 list1 = []
481 481 list2 = []
482 482 dat = data_azi
483 483 for i in reversed(range(1,len(dat))):
484 484 if dat[i]>dat[i-1]:
485 485 diff = int(dat[i])-int(dat[i-1])
486 486 else:
487 487 diff = 360+int(dat[i])-int(dat[i-1])
488 488 if diff > 1:
489 489 list1.append(i-1)
490 490 list2.append(diff-1)
491 491 return list1,list2
492 492
493 493 def fixDATANEW(self,data_azi,data_weather):
494 494 list1,list2 = self.analizeDATA(data_azi)
495 495 if len(list1)== 0:
496 496 return data_azi,data_weather
497 497 else:
498 498 resize = 0
499 499 for i in range(len(list2)):
500 500 resize= resize + list2[i]
501 501 new_data_azi = numpy.resize(data_azi,resize)
502 502 new_data_weather= numpy.resize(date_weather,resize)
503 503
504 504 for i in range(len(list2)):
505 505 j=0
506 506 position=list1[i]+1
507 507 for j in range(list2[i]):
508 508 new_data_azi[position+j]=new_data_azi[position+j-1]+1
509 509 return new_data_azi
510 510
511 511 def fixDATA(self,data_azi):
512 512 data=data_azi
513 513 for i in range(len(data)):
514 514 if numpy.isnan(data[i]):
515 515 data[i]=data[i-1]+1
516 516 return data
517 517
518 518 def replaceNAN(self,data_weather,data_azi,val):
519 519 data= data_azi
520 520 data_T= data_weather
521 521 if data.shape[0]> data_T.shape[0]:
522 522 data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
523 523 c = 0
524 524 for i in range(len(data)):
525 525 if numpy.isnan(data[i]):
526 526 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
527 527 else:
528 528 data_N[i,:]=data_T[c,:]
529 529 c=c+1
530 530 return data_N
531 531 else:
532 532 for i in range(len(data)):
533 533 if numpy.isnan(data[i]):
534 534 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
535 535 return data_T
536 536
537 537 def const_ploteo(self,data_weather,data_azi,step,res):
538 538 if self.ini==0:
539 539 #-------
540 540 n = (360/res)-len(data_azi)
541 541 #--------------------- new -------------------------
542 542 data_azi_new ,data_azi_old= self.globalCheckPED(data_azi)
543 543 #------------------------
544 544 start = data_azi_new[-1] + res
545 545 end = data_azi_new[0] - res
546 546 #------ new
547 547 self.last_data_azi = end
548 548 if start>end:
549 549 end = end + 360
550 550 azi_vacia = numpy.linspace(start,end,int(n))
551 551 azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia)
552 552 data_azi = numpy.hstack((data_azi_new,azi_vacia))
553 553 # RADAR
554 554 val_mean = numpy.mean(data_weather[:,-1])
555 555 self.val_mean = val_mean
556 556 data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
557 557 data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
558 558 data_weather = numpy.vstack((data_weather,data_weather_cmp))
559 559 else:
560 560 # azimuth
561 561 flag=0
562 562 start_azi = self.res_azi[0]
563 563 #-----------new------------
564 564 data_azi ,data_azi_old= self.globalCheckPED(data_azi)
565 565 data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
566 566 #--------------------------
567 567 start = data_azi[0]
568 568 end = data_azi[-1]
569 569 self.last_data_azi= end
570 570 if start< start_azi:
571 571 start = start +360
572 572 if end <start_azi:
573 573 end = end +360
574 574
575 575 pos_ini = int((start-start_azi)/res)
576 576 len_azi = len(data_azi)
577 577 if (360-pos_ini)<len_azi:
578 578 if pos_ini+1==360:
579 579 pos_ini=0
580 580 else:
581 581 flag=1
582 582 dif= 360-pos_ini
583 583 comp= len_azi-dif
584 584 #-----------------
585 585 if flag==0:
586 586 # AZIMUTH
587 587 self.res_azi[pos_ini:pos_ini+len_azi] = data_azi
588 588 # RADAR
589 589 self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather
590 590 else:
591 591 # AZIMUTH
592 592 self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif]
593 593 self.res_azi[0:comp] = data_azi[dif:]
594 594 # RADAR
595 595 self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:]
596 596 self.res_weather[0:comp,:] = data_weather[dif:,:]
597 597 flag=0
598 598 data_azi = self.res_azi
599 599 data_weather = self.res_weather
600 600
601 601 return data_weather,data_azi
602 602
603 603 def plot(self):
604 604 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
605 605 data = self.data[-1]
606 606 r = self.data.yrange
607 607 delta_height = r[1]-r[0]
608 608 r_mask = numpy.where(r>=0)[0]
609 609 r = numpy.arange(len(r_mask))*delta_height
610 610 self.y = 2*r
611 611 # RADAR
612 612 #data_weather = data['weather']
613 613 # PEDESTAL
614 614 #data_azi = data['azi']
615 615 res = 1
616 616 # STEP
617 617 step = (360/(res*data['weather'].shape[0]))
618 618
619 619 self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res)
620 620 self.res_ele = numpy.mean(data['ele'])
621 621 ################# PLOTEO ###################
622 622 for i,ax in enumerate(self.axes):
623 623 self.zmin = self.zmin if self.zmin else 20
624 624 self.zmax = self.zmax if self.zmax else 80
625 625 if ax.firsttime:
626 626 plt.clf()
627 627 cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=self.zmin, vmax=self.zmax)
628 628 else:
629 629 plt.clf()
630 630 cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=self.zmin, vmax=self.zmax)
631 631 caax = cgax.parasites[0]
632 632 paax = cgax.parasites[1]
633 633 cbar = plt.gcf().colorbar(pm, pad=0.075)
634 634 caax.set_xlabel('x_range [km]')
635 635 caax.set_ylabel('y_range [km]')
636 636 plt.text(1.0, 1.05, 'Azimuth '+str(thisDatetime)+" Step "+str(self.ini)+ " EL: "+str(round(self.res_ele, 1)), transform=caax.transAxes, va='bottom',ha='right')
637 637
638 638 self.ini= self.ini+1
639 639
640 640
641 641 class WeatherRHIPlot(Plot):
642 642 CODE = 'weather'
643 643 plot_name = 'weather'
644 644 plot_type = 'rhistyle'
645 645 buffering = False
646 646 data_ele_tmp = None
647 647
648 648 def setup(self):
649 649 print("********************")
650 650 print("********************")
651 651 print("********************")
652 652 print("SETUP WEATHER PLOT")
653 653 self.ncols = 1
654 654 self.nrows = 1
655 655 self.nplots= 1
656 656 self.ylabel= 'Range [Km]'
657 657 self.titles= ['Weather']
658 658 if self.channels is not None:
659 659 self.nplots = len(self.channels)
660 660 self.nrows = len(self.channels)
661 661 else:
662 662 self.nplots = self.data.shape(self.CODE)[0]
663 663 self.nrows = self.nplots
664 664 self.channels = list(range(self.nplots))
665 665 print("channels",self.channels)
666 666 print("que saldra", self.data.shape(self.CODE)[0])
667 667 self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
668 668 print("self.titles",self.titles)
669 669 self.colorbar=False
670 670 self.width =12
671 671 self.height =8
672 672 self.ini =0
673 673 self.len_azi =0
674 674 self.buffer_ini = None
675 675 self.buffer_ele = None
676 676 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
677 677 self.flag =0
678 678 self.indicador= 0
679 679 self.last_data_ele = None
680 680 self.val_mean = None
681 681
682 682 def update(self, dataOut):
683 683
684 684 data = {}
685 685 meta = {}
686 686 if hasattr(dataOut, 'dataPP_POWER'):
687 687 factor = 1
688 688 if hasattr(dataOut, 'nFFTPoints'):
689 689 factor = dataOut.normFactor
690 690 print("dataOut",dataOut.data_360.shape)
691 691 #
692 692 data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
693 693 #
694 694 #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
695 695 data['azi'] = dataOut.data_azi
696 696 data['ele'] = dataOut.data_ele
697 697 #print("UPDATE")
698 698 #print("data[weather]",data['weather'].shape)
699 699 #print("data[azi]",data['azi'])
700 700 return data, meta
701 701
702 702 def get2List(self,angulos):
703 703 list1=[]
704 704 list2=[]
705 705 for i in reversed(range(len(angulos))):
706 706 if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
707 707 diff_ = angulos[i]-angulos[i-1]
708 708 if abs(diff_) >1.5:
709 709 list1.append(i-1)
710 710 list2.append(diff_)
711 711 return list(reversed(list1)),list(reversed(list2))
712 712
713 713 def fixData90(self,list_,ang_):
714 714 if list_[0]==-1:
715 715 vec = numpy.where(ang_<ang_[0])
716 716 ang_[vec] = ang_[vec]+90
717 717 return ang_
718 718 return ang_
719 719
720 720 def fixData90HL(self,angulos):
721 721 vec = numpy.where(angulos>=90)
722 722 angulos[vec]=angulos[vec]-90
723 723 return angulos
724 724
725 725
726 726 def search_pos(self,pos,list_):
727 727 for i in range(len(list_)):
728 728 if pos == list_[i]:
729 729 return True,i
730 730 i=None
731 731 return False,i
732 732
733 733 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
734 734 size = len(ang_)
735 735 size2 = 0
736 736 for i in range(len(list2_)):
737 737 size2=size2+round(abs(list2_[i]))-1
738 738 new_size= size+size2
739 739 ang_new = numpy.zeros(new_size)
740 740 ang_new2 = numpy.zeros(new_size)
741 741
742 742 tmp = 0
743 743 c = 0
744 744 for i in range(len(ang_)):
745 745 ang_new[tmp +c] = ang_[i]
746 746 ang_new2[tmp+c] = ang_[i]
747 747 condition , value = self.search_pos(i,list1_)
748 748 if condition:
749 749 pos = tmp + c + 1
750 750 for k in range(round(abs(list2_[value]))-1):
751 751 if tipo_case==0 or tipo_case==3:#subida
752 752 ang_new[pos+k] = ang_new[pos+k-1]+1
753 753 ang_new2[pos+k] = numpy.nan
754 754 elif tipo_case==1 or tipo_case==2:#bajada
755 755 ang_new[pos+k] = ang_new[pos+k-1]-1
756 756 ang_new2[pos+k] = numpy.nan
757 757
758 758 tmp = pos +k
759 759 c = 0
760 760 c=c+1
761 761 return ang_new,ang_new2
762 762
763 763 def globalCheckPED(self,angulos,tipo_case):
764 764 l1,l2 = self.get2List(angulos)
765 765 ##print("l1",l1)
766 766 ##print("l2",l2)
767 767 if len(l1)>0:
768 768 #angulos2 = self.fixData90(list_=l1,ang_=angulos)
769 769 #l1,l2 = self.get2List(angulos2)
770 770 ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
771 771 #ang1_ = self.fixData90HL(ang1_)
772 772 #ang2_ = self.fixData90HL(ang2_)
773 773 else:
774 774 ang1_= angulos
775 775 ang2_= angulos
776 776 return ang1_,ang2_
777 777
778 778
779 779 def replaceNAN(self,data_weather,data_ele,val):
780 780 data= data_ele
781 781 data_T= data_weather
782 782 if data.shape[0]> data_T.shape[0]:
783 783 data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
784 784 c = 0
785 785 for i in range(len(data)):
786 786 if numpy.isnan(data[i]):
787 787 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
788 788 else:
789 789 data_N[i,:]=data_T[c,:]
790 790 c=c+1
791 791 return data_N
792 792 else:
793 793 for i in range(len(data)):
794 794 if numpy.isnan(data[i]):
795 795 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
796 796 return data_T
797 797
798 798 def check_case(self,data_ele,ang_max,ang_min):
799 799 start = data_ele[0]
800 800 end = data_ele[-1]
801 801 number = (end-start)
802 802 len_ang=len(data_ele)
803 803 print("start",start)
804 804 print("end",end)
805 805 print("number",number)
806 806
807 807 print("len_ang",len_ang)
808 808
809 809 #exit(1)
810 810
811 811 if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
812 812 return 0
813 813 #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
814 814 # return 1
815 815 elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
816 816 return 1
817 817 elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
818 818 return 2
819 819 elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
820 820 return 3
821 821
822 822
823 823 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min):
824 824 ang_max= ang_max
825 825 ang_min= ang_min
826 826 data_weather=data_weather
827 827 val_ch=val_ch
828 828 ##print("*********************DATA WEATHER**************************************")
829 829 ##print(data_weather)
830 830 if self.ini==0:
831 831 '''
832 832 print("**********************************************")
833 833 print("**********************************************")
834 834 print("***************ini**************")
835 835 print("**********************************************")
836 836 print("**********************************************")
837 837 '''
838 838 #print("data_ele",data_ele)
839 839 #----------------------------------------------------------
840 840 tipo_case = self.check_case(data_ele,ang_max,ang_min)
841 841 print("check_case",tipo_case)
842 842 #exit(1)
843 843 #--------------------- new -------------------------
844 844 data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
845 845
846 846 #-------------------------CAMBIOS RHI---------------------------------
847 847 start= ang_min
848 848 end = ang_max
849 849 n= (ang_max-ang_min)/res
850 850 #------ new
851 851 self.start_data_ele = data_ele_new[0]
852 852 self.end_data_ele = data_ele_new[-1]
853 853 if tipo_case==0 or tipo_case==3: # SUBIDA
854 854 n1= round(self.start_data_ele)- start
855 855 n2= end - round(self.end_data_ele)
856 856 print(self.start_data_ele)
857 857 print(self.end_data_ele)
858 858 if n1>0:
859 859 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
860 860 ele1_nan= numpy.ones(n1)*numpy.nan
861 861 data_ele = numpy.hstack((ele1,data_ele_new))
862 862 print("ele1_nan",ele1_nan.shape)
863 863 print("data_ele_old",data_ele_old.shape)
864 864 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
865 865 if n2>0:
866 866 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
867 867 ele2_nan= numpy.ones(n2)*numpy.nan
868 868 data_ele = numpy.hstack((data_ele,ele2))
869 869 print("ele2_nan",ele2_nan.shape)
870 870 print("data_ele_old",data_ele_old.shape)
871 871 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
872 872
873 873 if tipo_case==1 or tipo_case==2: # BAJADA
874 874 data_ele_new = data_ele_new[::-1] # reversa
875 875 data_ele_old = data_ele_old[::-1]# reversa
876 876 data_weather = data_weather[::-1,:]# reversa
877 877 vec= numpy.where(data_ele_new<ang_max)
878 878 data_ele_new = data_ele_new[vec]
879 879 data_ele_old = data_ele_old[vec]
880 880 data_weather = data_weather[vec[0]]
881 881 vec2= numpy.where(0<data_ele_new)
882 882 data_ele_new = data_ele_new[vec2]
883 883 data_ele_old = data_ele_old[vec2]
884 884 data_weather = data_weather[vec2[0]]
885 885 self.start_data_ele = data_ele_new[0]
886 886 self.end_data_ele = data_ele_new[-1]
887 887
888 888 n1= round(self.start_data_ele)- start
889 889 n2= end - round(self.end_data_ele)-1
890 890 print(self.start_data_ele)
891 891 print(self.end_data_ele)
892 892 if n1>0:
893 893 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
894 894 ele1_nan= numpy.ones(n1)*numpy.nan
895 895 data_ele = numpy.hstack((ele1,data_ele_new))
896 896 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
897 897 if n2>0:
898 898 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
899 899 ele2_nan= numpy.ones(n2)*numpy.nan
900 900 data_ele = numpy.hstack((data_ele,ele2))
901 901 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
902 902 # RADAR
903 903 # NOTA data_ele y data_weather es la variable que retorna
904 904 val_mean = numpy.mean(data_weather[:,-1])
905 905 self.val_mean = val_mean
906 906 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
907 907 self.data_ele_tmp[val_ch]= data_ele_old
908 908 else:
909 909 #print("**********************************************")
910 910 #print("****************VARIABLE**********************")
911 911 #-------------------------CAMBIOS RHI---------------------------------
912 912 #---------------------------------------------------------------------
913 913 ##print("INPUT data_ele",data_ele)
914 914 flag=0
915 915 start_ele = self.res_ele[0]
916 916 tipo_case = self.check_case(data_ele,ang_max,ang_min)
917 917 #print("TIPO DE DATA",tipo_case)
918 918 #-----------new------------
919 919 data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
920 920 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
921 921
922 922 #-------------------------------NEW RHI ITERATIVO-------------------------
923 923
924 924 if tipo_case==0 : # SUBIDA
925 925 vec = numpy.where(data_ele<ang_max)
926 926 data_ele = data_ele[vec]
927 927 data_ele_old = data_ele_old[vec]
928 928 data_weather = data_weather[vec[0]]
929 929
930 930 vec2 = numpy.where(0<data_ele)
931 931 data_ele= data_ele[vec2]
932 932 data_ele_old= data_ele_old[vec2]
933 933 ##print(data_ele_new)
934 934 data_weather= data_weather[vec2[0]]
935 935
936 936 new_i_ele = int(round(data_ele[0]))
937 937 new_f_ele = int(round(data_ele[-1]))
938 938 #print(new_i_ele)
939 939 #print(new_f_ele)
940 940 #print(data_ele,len(data_ele))
941 941 #print(data_ele_old,len(data_ele_old))
942 942 if new_i_ele< 2:
943 943 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
944 944 self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
945 945 self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
946 946 self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
947 947 self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
948 948 data_ele = self.res_ele
949 949 data_weather = self.res_weather[val_ch]
950 950
951 951 elif tipo_case==1 : #BAJADA
952 952 data_ele = data_ele[::-1] # reversa
953 953 data_ele_old = data_ele_old[::-1]# reversa
954 954 data_weather = data_weather[::-1,:]# reversa
955 955 vec= numpy.where(data_ele<ang_max)
956 956 data_ele = data_ele[vec]
957 957 data_ele_old = data_ele_old[vec]
958 958 data_weather = data_weather[vec[0]]
959 959 vec2= numpy.where(0<data_ele)
960 960 data_ele = data_ele[vec2]
961 961 data_ele_old = data_ele_old[vec2]
962 962 data_weather = data_weather[vec2[0]]
963 963
964 964
965 965 new_i_ele = int(round(data_ele[0]))
966 966 new_f_ele = int(round(data_ele[-1]))
967 967 #print(data_ele)
968 968 #print(ang_max)
969 969 #print(data_ele_old)
970 970 if new_i_ele <= 1:
971 971 new_i_ele = 1
972 972 if round(data_ele[-1])>=ang_max-1:
973 973 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
974 974 self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
975 975 self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
976 976 self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
977 977 self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
978 978 data_ele = self.res_ele
979 979 data_weather = self.res_weather[val_ch]
980 980
981 981 elif tipo_case==2: #bajada
982 982 vec = numpy.where(data_ele<ang_max)
983 983 data_ele = data_ele[vec]
984 984 data_weather= data_weather[vec[0]]
985 985
986 986 len_vec = len(vec)
987 987 data_ele_new = data_ele[::-1] # reversa
988 988 data_weather = data_weather[::-1,:]
989 989 new_i_ele = int(data_ele_new[0])
990 990 new_f_ele = int(data_ele_new[-1])
991 991
992 992 n1= new_i_ele- ang_min
993 993 n2= ang_max - new_f_ele-1
994 994 if n1>0:
995 995 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
996 996 ele1_nan= numpy.ones(n1)*numpy.nan
997 997 data_ele = numpy.hstack((ele1,data_ele_new))
998 998 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
999 999 if n2>0:
1000 1000 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1001 1001 ele2_nan= numpy.ones(n2)*numpy.nan
1002 1002 data_ele = numpy.hstack((data_ele,ele2))
1003 1003 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1004 1004
1005 1005 self.data_ele_tmp[val_ch] = data_ele_old
1006 1006 self.res_ele = data_ele
1007 1007 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1008 1008 data_ele = self.res_ele
1009 1009 data_weather = self.res_weather[val_ch]
1010 1010
1011 1011 elif tipo_case==3:#subida
1012 1012 vec = numpy.where(0<data_ele)
1013 1013 data_ele= data_ele[vec]
1014 1014 data_ele_new = data_ele
1015 1015 data_ele_old= data_ele_old[vec]
1016 1016 data_weather= data_weather[vec[0]]
1017 1017 pos_ini = numpy.argmin(data_ele)
1018 1018 if pos_ini>0:
1019 1019 len_vec= len(data_ele)
1020 1020 vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
1021 1021 #print(vec3)
1022 1022 data_ele= data_ele[vec3]
1023 1023 data_ele_new = data_ele
1024 1024 data_ele_old= data_ele_old[vec3]
1025 1025 data_weather= data_weather[vec3]
1026 1026
1027 1027 new_i_ele = int(data_ele_new[0])
1028 1028 new_f_ele = int(data_ele_new[-1])
1029 1029 n1= new_i_ele- ang_min
1030 1030 n2= ang_max - new_f_ele-1
1031 1031 if n1>0:
1032 1032 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
1033 1033 ele1_nan= numpy.ones(n1)*numpy.nan
1034 1034 data_ele = numpy.hstack((ele1,data_ele_new))
1035 1035 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
1036 1036 if n2>0:
1037 1037 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1038 1038 ele2_nan= numpy.ones(n2)*numpy.nan
1039 1039 data_ele = numpy.hstack((data_ele,ele2))
1040 1040 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1041 1041
1042 1042 self.data_ele_tmp[val_ch] = data_ele_old
1043 1043 self.res_ele = data_ele
1044 1044 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1045 1045 data_ele = self.res_ele
1046 1046 data_weather = self.res_weather[val_ch]
1047 1047 #print("self.data_ele_tmp",self.data_ele_tmp)
1048 1048 return data_weather,data_ele
1049 1049
1050 1050
1051 1051 def plot(self):
1052 1052 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
1053 1053 data = self.data[-1]
1054 1054 r = self.data.yrange
1055 1055 delta_height = r[1]-r[0]
1056 1056 r_mask = numpy.where(r>=0)[0]
1057 1057 ##print("delta_height",delta_height)
1058 1058 #print("r_mask",r_mask,len(r_mask))
1059 1059 r = numpy.arange(len(r_mask))*delta_height
1060 1060 self.y = 2*r
1061 1061 res = 1
1062 1062 ###print("data['weather'].shape[0]",data['weather'].shape[0])
1063 1063 ang_max = self.ang_max
1064 1064 ang_min = self.ang_min
1065 1065 var_ang =ang_max - ang_min
1066 1066 step = (int(var_ang)/(res*data['weather'].shape[0]))
1067 1067 ###print("step",step)
1068 1068 #--------------------------------------------------------
1069 1069 ##print('weather',data['weather'].shape)
1070 1070 ##print('ele',data['ele'].shape)
1071 1071
1072 1072 ###self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
1073 1073 ###self.res_azi = numpy.mean(data['azi'])
1074 1074 ###print("self.res_ele",self.res_ele)
1075 1075 plt.clf()
1076 1076 subplots = [121, 122]
1077 1077 cg={'angular_spacing': 20.}
1078 1078 if self.ini==0:
1079 1079 self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
1080 1080 self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
1081 1081 print("SHAPE",self.data_ele_tmp.shape)
1082 1082
1083 1083 for i,ax in enumerate(self.axes):
1084 1084 self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
1085 1085 self.res_azi = numpy.mean(data['azi'])
1086 1086 if i==0:
1087 1087 print("*****************************************************************************to plot**************************",self.res_weather[i].shape)
1088 1088 self.zmin = self.zmin if self.zmin else 20
1089 1089 self.zmax = self.zmax if self.zmax else 80
1090 1090 if ax.firsttime:
1091 1091 #plt.clf()
1092 1092 cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj=cg,vmin=self.zmin, vmax=self.zmax)
1093 1093 #fig=self.figures[0]
1094 1094 else:
1095 1095 #plt.clf()
1096 1096 if i==0:
1097 1097 print(self.res_weather[i])
1098 1098 print(self.res_ele)
1099 1099 cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj=cg,vmin=self.zmin, vmax=self.zmax)
1100 1100 caax = cgax.parasites[0]
1101 1101 paax = cgax.parasites[1]
1102 1102 cbar = plt.gcf().colorbar(pm, pad=0.075)
1103 1103 caax.set_xlabel('x_range [km]')
1104 1104 caax.set_ylabel('y_range [km]')
1105 1105 plt.text(1.0, 1.05, 'Elevacion '+str(thisDatetime)+" Step "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right')
1106 1106 print("***************************self.ini****************************",self.ini)
1107 1107 self.ini= self.ini+1
1108 1108
1109 1109 class Weather_vRF_Plot(Plot):
1110 1110 CODE = 'PPI'
1111 1111 plot_name = 'PPI'
1112 1112 #plot_type = 'ppistyle'
1113 1113 buffering = False
1114 1114
1115 1115 def setup(self):
1116 1116
1117 1117 self.ncols = 1
1118 1118 self.nrows = 1
1119 1119 self.width =8
1120 1120 self.height =8
1121 1121 self.nplots= 1
1122 1122 self.ylabel= 'Range [Km]'
1123 1123 self.xlabel= 'Range [Km]'
1124 1124 self.titles= ['PPI']
1125 1125 self.polar = True
1126 1126 if self.channels is not None:
1127 1127 self.nplots = len(self.channels)
1128 1128 self.nrows = len(self.channels)
1129 1129 else:
1130 1130 self.nplots = self.data.shape(self.CODE)[0]
1131 1131 self.nrows = self.nplots
1132 1132 self.channels = list(range(self.nplots))
1133 1133
1134 1134 if self.CODE == 'POWER':
1135 1135 self.cb_label = r'Power (dB)'
1136 1136 elif self.CODE == 'DOPPLER':
1137 1137 self.cb_label = r'Velocity (m/s)'
1138 1138 self.colorbar=True
1139 1139 self.width = 9
1140 1140 self.height =8
1141 1141 self.ini =0
1142 1142 self.len_azi =0
1143 1143 self.buffer_ini = None
1144 1144 self.buffer_ele = None
1145 1145 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.15, 'right': 0.9, 'bottom': 0.08})
1146 1146 self.flag =0
1147 1147 self.indicador= 0
1148 1148 self.last_data_ele = None
1149 1149 self.val_mean = None
1150 1150
1151 1151 def update(self, dataOut):
1152 1152
1153 1153 data = {}
1154 1154 meta = {}
1155 1155 if hasattr(dataOut, 'dataPP_POWER'):
1156 1156 factor = 1
1157 1157 if hasattr(dataOut, 'nFFTPoints'):
1158 1158 factor = dataOut.normFactor
1159 1159
1160 1160 if 'pow' in self.attr_data[0].lower():
1161 1161 data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
1162 1162 else:
1163 1163 data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
1164 1164
1165 1165 data['azi'] = dataOut.data_azi
1166 1166 data['ele'] = dataOut.data_ele
1167 1167
1168 1168 return data, meta
1169 1169
1170 1170 def plot(self):
1171 1171 data = self.data[-1]
1172 1172 r = self.data.yrange
1173 1173 delta_height = r[1]-r[0]
1174 1174 r_mask = numpy.where(r>=0)[0]
1175 1175 self.r_mask = r_mask
1176 1176 r = numpy.arange(len(r_mask))*delta_height
1177 1177 self.y = 2*r
1178 1178
1179 1179 z = data['data'][self.channels[0]][:,r_mask]
1180 1180
1181 1181 self.titles = []
1182 1182
1183 1183 self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
1184 1184 self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
1185 1185 self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
1186 1186 self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
1187 1187 self.ang_min = self.ang_min if self.ang_min else 0
1188 1188 self.ang_max = self.ang_max if self.ang_max else 360
1189 1189
1190 1190 r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) )
1191 1191
1192 1192 for i,ax in enumerate(self.axes):
1193 1193
1194 1194 if ax.firsttime:
1195 1195 ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
1196 1196 ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
1197 ax.set_theta_direction(-1)
1197 1198
1198 1199 else:
1199 1200 ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
1200 1201 ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
1202 ax.set_theta_direction(-1)
1201 1203
1202 1204 ax.grid(True)
1203 1205
1204 1206 if len(self.channels) !=1:
1205 1207 self.titles = ['PPI {} at EL: {} Channel {}'.format(self.self.labels[x], str(round(numpy.mean(data['ele']),1)), x) for x in range(self.nrows)]
1206 1208 else:
1207 1209 self.titles = ['PPI {} at EL: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['ele']),1)), self.channels[0])]
1208 1210
1209 1211 class WeatherRHI_vRF2_Plot(Plot):
1210 1212 CODE = 'weather'
1211 1213 plot_name = 'weather'
1212 1214 plot_type = 'rhistyle'
1213 1215 buffering = False
1214 1216 data_ele_tmp = None
1215 1217
1216 1218 def setup(self):
1217 1219 print("********************")
1218 1220 print("********************")
1219 1221 print("********************")
1220 1222 print("SETUP WEATHER PLOT")
1221 1223 self.ncols = 1
1222 1224 self.nrows = 1
1223 1225 self.nplots= 1
1224 1226 self.ylabel= 'Range [Km]'
1225 1227 self.titles= ['Weather']
1226 1228 if self.channels is not None:
1227 1229 self.nplots = len(self.channels)
1228 1230 self.nrows = len(self.channels)
1229 1231 else:
1230 1232 self.nplots = self.data.shape(self.CODE)[0]
1231 1233 self.nrows = self.nplots
1232 1234 self.channels = list(range(self.nplots))
1233 1235 print("channels",self.channels)
1234 1236 print("que saldra", self.data.shape(self.CODE)[0])
1235 1237 self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
1236 1238 print("self.titles",self.titles)
1237 1239 self.colorbar=False
1238 1240 self.width =8
1239 1241 self.height =8
1240 1242 self.ini =0
1241 1243 self.len_azi =0
1242 1244 self.buffer_ini = None
1243 1245 self.buffer_ele = None
1244 1246 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
1245 1247 self.flag =0
1246 1248 self.indicador= 0
1247 1249 self.last_data_ele = None
1248 1250 self.val_mean = None
1249 1251
1250 1252 def update(self, dataOut):
1251 1253
1252 1254 data = {}
1253 1255 meta = {}
1254 1256 if hasattr(dataOut, 'dataPP_POWER'):
1255 1257 factor = 1
1256 1258 if hasattr(dataOut, 'nFFTPoints'):
1257 1259 factor = dataOut.normFactor
1258 1260 print("dataOut",dataOut.data_360.shape)
1259 1261 #
1260 1262 data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
1261 1263 #
1262 1264 #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
1263 1265 data['azi'] = dataOut.data_azi
1264 1266 data['ele'] = dataOut.data_ele
1265 1267 data['case_flag'] = dataOut.case_flag
1266 1268 #print("UPDATE")
1267 1269 #print("data[weather]",data['weather'].shape)
1268 1270 #print("data[azi]",data['azi'])
1269 1271 return data, meta
1270 1272
1271 1273 def get2List(self,angulos):
1272 1274 list1=[]
1273 1275 list2=[]
1274 1276 for i in reversed(range(len(angulos))):
1275 1277 if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
1276 1278 diff_ = angulos[i]-angulos[i-1]
1277 1279 if abs(diff_) >1.5:
1278 1280 list1.append(i-1)
1279 1281 list2.append(diff_)
1280 1282 return list(reversed(list1)),list(reversed(list2))
1281 1283
1282 1284 def fixData90(self,list_,ang_):
1283 1285 if list_[0]==-1:
1284 1286 vec = numpy.where(ang_<ang_[0])
1285 1287 ang_[vec] = ang_[vec]+90
1286 1288 return ang_
1287 1289 return ang_
1288 1290
1289 1291 def fixData90HL(self,angulos):
1290 1292 vec = numpy.where(angulos>=90)
1291 1293 angulos[vec]=angulos[vec]-90
1292 1294 return angulos
1293 1295
1294 1296
1295 1297 def search_pos(self,pos,list_):
1296 1298 for i in range(len(list_)):
1297 1299 if pos == list_[i]:
1298 1300 return True,i
1299 1301 i=None
1300 1302 return False,i
1301 1303
1302 1304 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
1303 1305 size = len(ang_)
1304 1306 size2 = 0
1305 1307 for i in range(len(list2_)):
1306 1308 size2=size2+round(abs(list2_[i]))-1
1307 1309 new_size= size+size2
1308 1310 ang_new = numpy.zeros(new_size)
1309 1311 ang_new2 = numpy.zeros(new_size)
1310 1312
1311 1313 tmp = 0
1312 1314 c = 0
1313 1315 for i in range(len(ang_)):
1314 1316 ang_new[tmp +c] = ang_[i]
1315 1317 ang_new2[tmp+c] = ang_[i]
1316 1318 condition , value = self.search_pos(i,list1_)
1317 1319 if condition:
1318 1320 pos = tmp + c + 1
1319 1321 for k in range(round(abs(list2_[value]))-1):
1320 1322 if tipo_case==0 or tipo_case==3:#subida
1321 1323 ang_new[pos+k] = ang_new[pos+k-1]+1
1322 1324 ang_new2[pos+k] = numpy.nan
1323 1325 elif tipo_case==1 or tipo_case==2:#bajada
1324 1326 ang_new[pos+k] = ang_new[pos+k-1]-1
1325 1327 ang_new2[pos+k] = numpy.nan
1326 1328
1327 1329 tmp = pos +k
1328 1330 c = 0
1329 1331 c=c+1
1330 1332 return ang_new,ang_new2
1331 1333
1332 1334 def globalCheckPED(self,angulos,tipo_case):
1333 1335 l1,l2 = self.get2List(angulos)
1334 1336 ##print("l1",l1)
1335 1337 ##print("l2",l2)
1336 1338 if len(l1)>0:
1337 1339 #angulos2 = self.fixData90(list_=l1,ang_=angulos)
1338 1340 #l1,l2 = self.get2List(angulos2)
1339 1341 ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
1340 1342 #ang1_ = self.fixData90HL(ang1_)
1341 1343 #ang2_ = self.fixData90HL(ang2_)
1342 1344 else:
1343 1345 ang1_= angulos
1344 1346 ang2_= angulos
1345 1347 return ang1_,ang2_
1346 1348
1347 1349
1348 1350 def replaceNAN(self,data_weather,data_ele,val):
1349 1351 data= data_ele
1350 1352 data_T= data_weather
1351 1353 if data.shape[0]> data_T.shape[0]:
1352 1354 data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
1353 1355 c = 0
1354 1356 for i in range(len(data)):
1355 1357 if numpy.isnan(data[i]):
1356 1358 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
1357 1359 else:
1358 1360 data_N[i,:]=data_T[c,:]
1359 1361 c=c+1
1360 1362 return data_N
1361 1363 else:
1362 1364 for i in range(len(data)):
1363 1365 if numpy.isnan(data[i]):
1364 1366 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
1365 1367 return data_T
1366 1368
1367 1369 def check_case(self,data_ele,ang_max,ang_min):
1368 1370 start = data_ele[0]
1369 1371 end = data_ele[-1]
1370 1372 number = (end-start)
1371 1373 len_ang=len(data_ele)
1372 1374 print("start",start)
1373 1375 print("end",end)
1374 1376 print("number",number)
1375 1377
1376 1378 print("len_ang",len_ang)
1377 1379
1378 1380 #exit(1)
1379 1381
1380 1382 if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
1381 1383 return 0
1382 1384 #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
1383 1385 # return 1
1384 1386 elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
1385 1387 return 1
1386 1388 elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
1387 1389 return 2
1388 1390 elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
1389 1391 return 3
1390 1392
1391 1393
1392 1394 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min,case_flag):
1393 1395 ang_max= ang_max
1394 1396 ang_min= ang_min
1395 1397 data_weather=data_weather
1396 1398 val_ch=val_ch
1397 1399 ##print("*********************DATA WEATHER**************************************")
1398 1400 ##print(data_weather)
1399 1401 if self.ini==0:
1400 1402 '''
1401 1403 print("**********************************************")
1402 1404 print("**********************************************")
1403 1405 print("***************ini**************")
1404 1406 print("**********************************************")
1405 1407 print("**********************************************")
1406 1408 '''
1407 1409 #print("data_ele",data_ele)
1408 1410 #----------------------------------------------------------
1409 1411 tipo_case = case_flag[-1]
1410 1412 #tipo_case = self.check_case(data_ele,ang_max,ang_min)
1411 1413 print("check_case",tipo_case)
1412 1414 #exit(1)
1413 1415 #--------------------- new -------------------------
1414 1416 data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
1415 1417
1416 1418 #-------------------------CAMBIOS RHI---------------------------------
1417 1419 start= ang_min
1418 1420 end = ang_max
1419 1421 n= (ang_max-ang_min)/res
1420 1422 #------ new
1421 1423 self.start_data_ele = data_ele_new[0]
1422 1424 self.end_data_ele = data_ele_new[-1]
1423 1425 if tipo_case==0 or tipo_case==3: # SUBIDA
1424 1426 n1= round(self.start_data_ele)- start
1425 1427 n2= end - round(self.end_data_ele)
1426 1428 print(self.start_data_ele)
1427 1429 print(self.end_data_ele)
1428 1430 if n1>0:
1429 1431 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
1430 1432 ele1_nan= numpy.ones(n1)*numpy.nan
1431 1433 data_ele = numpy.hstack((ele1,data_ele_new))
1432 1434 print("ele1_nan",ele1_nan.shape)
1433 1435 print("data_ele_old",data_ele_old.shape)
1434 1436 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
1435 1437 if n2>0:
1436 1438 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
1437 1439 ele2_nan= numpy.ones(n2)*numpy.nan
1438 1440 data_ele = numpy.hstack((data_ele,ele2))
1439 1441 print("ele2_nan",ele2_nan.shape)
1440 1442 print("data_ele_old",data_ele_old.shape)
1441 1443 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1442 1444
1443 1445 if tipo_case==1 or tipo_case==2: # BAJADA
1444 1446 data_ele_new = data_ele_new[::-1] # reversa
1445 1447 data_ele_old = data_ele_old[::-1]# reversa
1446 1448 data_weather = data_weather[::-1,:]# reversa
1447 1449 vec= numpy.where(data_ele_new<ang_max)
1448 1450 data_ele_new = data_ele_new[vec]
1449 1451 data_ele_old = data_ele_old[vec]
1450 1452 data_weather = data_weather[vec[0]]
1451 1453 vec2= numpy.where(0<data_ele_new)
1452 1454 data_ele_new = data_ele_new[vec2]
1453 1455 data_ele_old = data_ele_old[vec2]
1454 1456 data_weather = data_weather[vec2[0]]
1455 1457 self.start_data_ele = data_ele_new[0]
1456 1458 self.end_data_ele = data_ele_new[-1]
1457 1459
1458 1460 n1= round(self.start_data_ele)- start
1459 1461 n2= end - round(self.end_data_ele)-1
1460 1462 print(self.start_data_ele)
1461 1463 print(self.end_data_ele)
1462 1464 if n1>0:
1463 1465 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
1464 1466 ele1_nan= numpy.ones(n1)*numpy.nan
1465 1467 data_ele = numpy.hstack((ele1,data_ele_new))
1466 1468 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
1467 1469 if n2>0:
1468 1470 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
1469 1471 ele2_nan= numpy.ones(n2)*numpy.nan
1470 1472 data_ele = numpy.hstack((data_ele,ele2))
1471 1473 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1472 1474 # RADAR
1473 1475 # NOTA data_ele y data_weather es la variable que retorna
1474 1476 val_mean = numpy.mean(data_weather[:,-1])
1475 1477 self.val_mean = val_mean
1476 1478 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1477 1479 print("eleold",data_ele_old)
1478 1480 print(self.data_ele_tmp[val_ch])
1479 1481 print(data_ele_old.shape[0])
1480 1482 print(self.data_ele_tmp[val_ch].shape[0])
1481 1483 if (data_ele_old.shape[0]==91 or self.data_ele_tmp[val_ch].shape[0]==91):
1482 1484 import sys
1483 1485 print("EXIT",self.ini)
1484 1486
1485 1487 sys.exit(1)
1486 1488 self.data_ele_tmp[val_ch]= data_ele_old
1487 1489 else:
1488 1490 #print("**********************************************")
1489 1491 #print("****************VARIABLE**********************")
1490 1492 #-------------------------CAMBIOS RHI---------------------------------
1491 1493 #---------------------------------------------------------------------
1492 1494 ##print("INPUT data_ele",data_ele)
1493 1495 flag=0
1494 1496 start_ele = self.res_ele[0]
1495 1497 #tipo_case = self.check_case(data_ele,ang_max,ang_min)
1496 1498 tipo_case = case_flag[-1]
1497 1499 #print("TIPO DE DATA",tipo_case)
1498 1500 #-----------new------------
1499 1501 data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
1500 1502 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1501 1503
1502 1504 #-------------------------------NEW RHI ITERATIVO-------------------------
1503 1505
1504 1506 if tipo_case==0 : # SUBIDA
1505 1507 vec = numpy.where(data_ele<ang_max)
1506 1508 data_ele = data_ele[vec]
1507 1509 data_ele_old = data_ele_old[vec]
1508 1510 data_weather = data_weather[vec[0]]
1509 1511
1510 1512 vec2 = numpy.where(0<data_ele)
1511 1513 data_ele= data_ele[vec2]
1512 1514 data_ele_old= data_ele_old[vec2]
1513 1515 ##print(data_ele_new)
1514 1516 data_weather= data_weather[vec2[0]]
1515 1517
1516 1518 new_i_ele = int(round(data_ele[0]))
1517 1519 new_f_ele = int(round(data_ele[-1]))
1518 1520 #print(new_i_ele)
1519 1521 #print(new_f_ele)
1520 1522 #print(data_ele,len(data_ele))
1521 1523 #print(data_ele_old,len(data_ele_old))
1522 1524 if new_i_ele< 2:
1523 1525 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
1524 1526 self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
1525 1527 self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
1526 1528 self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
1527 1529 self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
1528 1530 data_ele = self.res_ele
1529 1531 data_weather = self.res_weather[val_ch]
1530 1532
1531 1533 elif tipo_case==1 : #BAJADA
1532 1534 data_ele = data_ele[::-1] # reversa
1533 1535 data_ele_old = data_ele_old[::-1]# reversa
1534 1536 data_weather = data_weather[::-1,:]# reversa
1535 1537 vec= numpy.where(data_ele<ang_max)
1536 1538 data_ele = data_ele[vec]
1537 1539 data_ele_old = data_ele_old[vec]
1538 1540 data_weather = data_weather[vec[0]]
1539 1541 vec2= numpy.where(0<data_ele)
1540 1542 data_ele = data_ele[vec2]
1541 1543 data_ele_old = data_ele_old[vec2]
1542 1544 data_weather = data_weather[vec2[0]]
1543 1545
1544 1546
1545 1547 new_i_ele = int(round(data_ele[0]))
1546 1548 new_f_ele = int(round(data_ele[-1]))
1547 1549 #print(data_ele)
1548 1550 #print(ang_max)
1549 1551 #print(data_ele_old)
1550 1552 if new_i_ele <= 1:
1551 1553 new_i_ele = 1
1552 1554 if round(data_ele[-1])>=ang_max-1:
1553 1555 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
1554 1556 self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
1555 1557 self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
1556 1558 self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
1557 1559 self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
1558 1560 data_ele = self.res_ele
1559 1561 data_weather = self.res_weather[val_ch]
1560 1562
1561 1563 elif tipo_case==2: #bajada
1562 1564 vec = numpy.where(data_ele<ang_max)
1563 1565 data_ele = data_ele[vec]
1564 1566 data_weather= data_weather[vec[0]]
1565 1567
1566 1568 len_vec = len(vec)
1567 1569 data_ele_new = data_ele[::-1] # reversa
1568 1570 data_weather = data_weather[::-1,:]
1569 1571 new_i_ele = int(data_ele_new[0])
1570 1572 new_f_ele = int(data_ele_new[-1])
1571 1573
1572 1574 n1= new_i_ele- ang_min
1573 1575 n2= ang_max - new_f_ele-1
1574 1576 if n1>0:
1575 1577 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
1576 1578 ele1_nan= numpy.ones(n1)*numpy.nan
1577 1579 data_ele = numpy.hstack((ele1,data_ele_new))
1578 1580 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
1579 1581 if n2>0:
1580 1582 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1581 1583 ele2_nan= numpy.ones(n2)*numpy.nan
1582 1584 data_ele = numpy.hstack((data_ele,ele2))
1583 1585 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1584 1586
1585 1587 self.data_ele_tmp[val_ch] = data_ele_old
1586 1588 self.res_ele = data_ele
1587 1589 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1588 1590 data_ele = self.res_ele
1589 1591 data_weather = self.res_weather[val_ch]
1590 1592
1591 1593 elif tipo_case==3:#subida
1592 1594 vec = numpy.where(0<data_ele)
1593 1595 data_ele= data_ele[vec]
1594 1596 data_ele_new = data_ele
1595 1597 data_ele_old= data_ele_old[vec]
1596 1598 data_weather= data_weather[vec[0]]
1597 1599 pos_ini = numpy.argmin(data_ele)
1598 1600 if pos_ini>0:
1599 1601 len_vec= len(data_ele)
1600 1602 vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
1601 1603 #print(vec3)
1602 1604 data_ele= data_ele[vec3]
1603 1605 data_ele_new = data_ele
1604 1606 data_ele_old= data_ele_old[vec3]
1605 1607 data_weather= data_weather[vec3]
1606 1608
1607 1609 new_i_ele = int(data_ele_new[0])
1608 1610 new_f_ele = int(data_ele_new[-1])
1609 1611 n1= new_i_ele- ang_min
1610 1612 n2= ang_max - new_f_ele-1
1611 1613 if n1>0:
1612 1614 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
1613 1615 ele1_nan= numpy.ones(n1)*numpy.nan
1614 1616 data_ele = numpy.hstack((ele1,data_ele_new))
1615 1617 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
1616 1618 if n2>0:
1617 1619 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1618 1620 ele2_nan= numpy.ones(n2)*numpy.nan
1619 1621 data_ele = numpy.hstack((data_ele,ele2))
1620 1622 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1621 1623
1622 1624 self.data_ele_tmp[val_ch] = data_ele_old
1623 1625 self.res_ele = data_ele
1624 1626 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1625 1627 data_ele = self.res_ele
1626 1628 data_weather = self.res_weather[val_ch]
1627 1629 #print("self.data_ele_tmp",self.data_ele_tmp)
1628 1630 return data_weather,data_ele
1629 1631
1630 1632
1631 1633 def plot(self):
1632 1634 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
1633 1635 data = self.data[-1]
1634 1636 r = self.data.yrange
1635 1637 delta_height = r[1]-r[0]
1636 1638 r_mask = numpy.where(r>=0)[0]
1637 1639 ##print("delta_height",delta_height)
1638 1640 #print("r_mask",r_mask,len(r_mask))
1639 1641 r = numpy.arange(len(r_mask))*delta_height
1640 1642 self.y = 2*r
1641 1643 res = 1
1642 1644 ###print("data['weather'].shape[0]",data['weather'].shape[0])
1643 1645 ang_max = self.ang_max
1644 1646 ang_min = self.ang_min
1645 1647 var_ang =ang_max - ang_min
1646 1648 step = (int(var_ang)/(res*data['weather'].shape[0]))
1647 1649 ###print("step",step)
1648 1650 #--------------------------------------------------------
1649 1651 ##print('weather',data['weather'].shape)
1650 1652 ##print('ele',data['ele'].shape)
1651 1653
1652 1654 ###self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
1653 1655 ###self.res_azi = numpy.mean(data['azi'])
1654 1656 ###print("self.res_ele",self.res_ele)
1655 1657 plt.clf()
1656 1658 subplots = [121, 122]
1657 1659 try:
1658 1660 if self.data[-2]['ele'].max()<data['ele'].max():
1659 1661 self.ini=0
1660 1662 except:
1661 1663 pass
1662 1664 if self.ini==0:
1663 1665 self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
1664 1666 self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
1665 1667 print("SHAPE",self.data_ele_tmp.shape)
1666 1668
1667 1669 for i,ax in enumerate(self.axes):
1668 1670 self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min,case_flag=self.data['case_flag'])
1669 1671 self.res_azi = numpy.mean(data['azi'])
1670 1672
1671 1673 if ax.firsttime:
1672 1674 #plt.clf()
1673 1675 print("Frist Plot")
1674 1676 cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
1675 1677 #fig=self.figures[0]
1676 1678 else:
1677 1679 #plt.clf()
1678 1680 print("ELSE PLOT")
1679 1681 cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
1680 1682 caax = cgax.parasites[0]
1681 1683 paax = cgax.parasites[1]
1682 1684 cbar = plt.gcf().colorbar(pm, pad=0.075)
1683 1685 caax.set_xlabel('x_range [km]')
1684 1686 caax.set_ylabel('y_range [km]')
1685 1687 plt.text(1.0, 1.05, 'Elevacion '+str(thisDatetime)+" Step "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right')
1686 1688 print("***************************self.ini****************************",self.ini)
1687 1689 self.ini= self.ini+1
1688 1690
1689 1691
1690 1692
1691 1693
1692 1694
1693 1695 class WeatherRHI_vRF4_Plot(Plot):
1694 1696 CODE = 'RHI'
1695 1697 plot_name = 'RHI'
1696 1698 #plot_type = 'rhistyle'
1697 1699 buffering = False
1698 1700
1699 1701 def setup(self):
1700 1702
1701 1703 self.ncols = 1
1702 1704 self.nrows = 1
1703 1705 self.nplots= 1
1704 1706 self.ylabel= 'Range [Km]'
1705 1707 self.xlabel= 'Range [Km]'
1706 1708 self.titles= ['RHI']
1707 1709 self.polar = True
1708 1710 self.grid = True
1709 1711 if self.channels is not None:
1710 1712 self.nplots = len(self.channels)
1711 1713 self.nrows = len(self.channels)
1712 1714 else:
1713 1715 self.nplots = self.data.shape(self.CODE)[0]
1714 1716 self.nrows = self.nplots
1715 1717 self.channels = list(range(self.nplots))
1716 1718
1717 1719 if self.CODE == 'Power':
1718 1720 self.cb_label = r'Power (dB)'
1719 1721 elif self.CODE == 'Doppler':
1720 1722 self.cb_label = r'Velocity (m/s)'
1721 1723 self.colorbar=True
1722 1724 self.width =8
1723 1725 self.height =8
1724 1726 self.ini =0
1725 1727 self.len_azi =0
1726 1728 self.buffer_ini = None
1727 1729 self.buffer_ele = None
1728 1730 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
1729 1731 self.flag =0
1730 1732 self.indicador= 0
1731 1733 self.last_data_ele = None
1732 1734 self.val_mean = None
1733 1735
1734 1736 def update(self, dataOut):
1735 1737
1736 1738 data = {}
1737 1739 meta = {}
1738 1740 if hasattr(dataOut, 'dataPP_POWER'):
1739 1741 factor = 1
1740 1742 if hasattr(dataOut, 'nFFTPoints'):
1741 1743 factor = dataOut.normFactor
1742 1744
1743 1745 if 'pow' in self.attr_data[0].lower():
1744 1746 data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
1745 1747 else:
1746 1748 data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
1747 1749
1748 1750 data['azi'] = dataOut.data_azi
1749 1751 data['ele'] = dataOut.data_ele
1750 1752
1751 1753 return data, meta
1752 1754
1753 1755 def plot(self):
1754 1756 data = self.data[-1]
1755 1757 r = self.data.yrange
1756 1758 delta_height = r[1]-r[0]
1757 1759 r_mask = numpy.where(r>=0)[0]
1758 1760 self.r_mask =r_mask
1759 1761 r = numpy.arange(len(r_mask))*delta_height
1760 1762 self.y = 2*r
1761 1763
1762 1764 z = data['data'][self.channels[0]][:,r_mask]
1763 1765
1764 1766 self.titles = []
1765 1767
1766 1768 self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
1767 1769 self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
1768 1770 self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
1769 1771 self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
1770 1772 self.ang_min = self.ang_min if self.ang_min else 0
1771 1773 self.ang_max = self.ang_max if self.ang_max else 90
1772 1774
1773 1775 r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) )
1774 1776
1775 1777 for i,ax in enumerate(self.axes):
1776 1778
1777 1779 if ax.firsttime:
1778 1780 ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
1779 1781 ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
1780 1782
1781 1783 else:
1782 1784 ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
1783 1785 ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
1784 1786 ax.grid(True)
1785 1787 if len(self.channels) !=1:
1786 1788 self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(numpy.mean(data['azi']),1)), x) for x in range(self.nrows)]
1787 1789 else:
1788 1790 self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['azi']),1)), self.channels[0])]
Show file before | Show file after | Hide comments
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
General Comments 0
You need to be logged in to leave comments. Login now