##// END OF EJS Templates
schain
RSS
Block360Update
rflores -
r1439:14a3ab7942a7
parent child
Show More
Side by Side Unified
Context file:
r1439:14a3ab7942a7 Loading diff...:

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

Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (513 lines changed) Show them Hide them
@@ -1,1865 +1,2378
1 1 import os
2 2 import datetime
3 3 import numpy
4 from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter
4 5
5 6 from schainpy.model.graphics.jroplot_base import Plot, plt
6 7 from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
7 8 from schainpy.utils import log
8 9 # libreria wradlib
9 10 import wradlib as wrl
10 11
11 12 EARTH_RADIUS = 6.3710e3
12 13
13 14
14 15 def ll2xy(lat1, lon1, lat2, lon2):
15 16
16 17 p = 0.017453292519943295
17 18 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
18 19 numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
19 20 r = 12742 * numpy.arcsin(numpy.sqrt(a))
20 21 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
21 22 * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
22 23 theta = -theta + numpy.pi/2
23 24 return r*numpy.cos(theta), r*numpy.sin(theta)
24 25
25 26
26 27 def km2deg(km):
27 28 '''
28 29 Convert distance in km to degrees
29 30 '''
30 31
31 32 return numpy.rad2deg(km/EARTH_RADIUS)
32 33
33 34
34 35
35 36 class SpectralMomentsPlot(SpectraPlot):
36 37 '''
37 38 Plot for Spectral Moments
38 39 '''
39 40 CODE = 'spc_moments'
40 41 # colormap = 'jet'
41 42 # plot_type = 'pcolor'
42 43
43 44 class DobleGaussianPlot(SpectraPlot):
44 45 '''
45 46 Plot for Double Gaussian Plot
46 47 '''
47 48 CODE = 'gaussian_fit'
48 49 # colormap = 'jet'
49 50 # plot_type = 'pcolor'
50 51
51 52 class DoubleGaussianSpectraCutPlot(SpectraCutPlot):
52 53 '''
53 54 Plot SpectraCut with Double Gaussian Fit
54 55 '''
55 56 CODE = 'cut_gaussian_fit'
56 57
57 58 class SnrPlot(RTIPlot):
58 59 '''
59 60 Plot for SNR Data
60 61 '''
61 62
62 63 CODE = 'snr'
63 64 colormap = 'jet'
64 65
65 66 def update(self, dataOut):
66 67
67 68 data = {
68 69 'snr': 10*numpy.log10(dataOut.data_snr)
69 70 }
70 71
71 72 return data, {}
72 73
73 74 class DopplerPlot(RTIPlot):
74 75 '''
75 76 Plot for DOPPLER Data (1st moment)
76 77 '''
77 78
78 79 CODE = 'dop'
79 80 colormap = 'jet'
80 81
81 82 def update(self, dataOut):
82 83
83 84 data = {
84 85 'dop': 10*numpy.log10(dataOut.data_dop)
85 86 }
86 87
87 88 return data, {}
88 89
89 90 class PowerPlot(RTIPlot):
90 91 '''
91 92 Plot for Power Data (0 moment)
92 93 '''
93 94
94 95 CODE = 'pow'
95 96 colormap = 'jet'
96 97
97 98 def update(self, dataOut):
98 99 data = {
99 100 'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor)
100 101 }
101 102 return data, {}
102 103
103 104 class SpectralWidthPlot(RTIPlot):
104 105 '''
105 106 Plot for Spectral Width Data (2nd moment)
106 107 '''
107 108
108 109 CODE = 'width'
109 110 colormap = 'jet'
110 111
111 112 def update(self, dataOut):
112 113
113 114 data = {
114 115 'width': dataOut.data_width
115 116 }
116 117
117 118 return data, {}
118 119
119 120 class SkyMapPlot(Plot):
120 121 '''
121 122 Plot for meteors detection data
122 123 '''
123 124
124 125 CODE = 'param'
125 126
126 127 def setup(self):
127 128
128 129 self.ncols = 1
129 130 self.nrows = 1
130 131 self.width = 7.2
131 132 self.height = 7.2
132 133 self.nplots = 1
133 134 self.xlabel = 'Zonal Zenith Angle (deg)'
134 135 self.ylabel = 'Meridional Zenith Angle (deg)'
135 136 self.polar = True
136 137 self.ymin = -180
137 138 self.ymax = 180
138 139 self.colorbar = False
139 140
140 141 def plot(self):
141 142
142 143 arrayParameters = numpy.concatenate(self.data['param'])
143 144 error = arrayParameters[:, -1]
144 145 indValid = numpy.where(error == 0)[0]
145 146 finalMeteor = arrayParameters[indValid, :]
146 147 finalAzimuth = finalMeteor[:, 3]
147 148 finalZenith = finalMeteor[:, 4]
148 149
149 150 x = finalAzimuth * numpy.pi / 180
150 151 y = finalZenith
151 152
152 153 ax = self.axes[0]
153 154
154 155 if ax.firsttime:
155 156 ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
156 157 else:
157 158 ax.plot.set_data(x, y)
158 159
159 160 dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
160 161 dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
161 162 title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
162 163 dt2,
163 164 len(x))
164 165 self.titles[0] = title
165 166
166 167
167 168 class GenericRTIPlot(Plot):
168 169 '''
169 170 Plot for data_xxxx object
170 171 '''
171 172
172 173 CODE = 'param'
173 174 colormap = 'viridis'
174 175 plot_type = 'pcolorbuffer'
175 176
176 177 def setup(self):
177 178 self.xaxis = 'time'
178 179 self.ncols = 1
179 180 self.nrows = self.data.shape('param')[0]
180 181 self.nplots = self.nrows
181 182 self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
182 183
183 184 if not self.xlabel:
184 185 self.xlabel = 'Time'
185 186
186 187 self.ylabel = 'Range [km]'
187 188 if not self.titles:
188 189 self.titles = ['Param {}'.format(x) for x in range(self.nrows)]
189 190
190 191 def update(self, dataOut):
191 192
192 193 data = {
193 194 'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)
194 195 }
195 196
196 197 meta = {}
197 198
198 199 return data, meta
199 200
200 201 def plot(self):
201 202 # self.data.normalize_heights()
202 203 self.x = self.data.times
203 204 self.y = self.data.yrange
204 205 self.z = self.data['param']
205 206 self.z = 10*numpy.log10(self.z)
206 207 self.z = numpy.ma.masked_invalid(self.z)
207 208
208 209 if self.decimation is None:
209 210 x, y, z = self.fill_gaps(self.x, self.y, self.z)
210 211 else:
211 212 x, y, z = self.fill_gaps(*self.decimate())
212 213
213 214 for n, ax in enumerate(self.axes):
214 215
215 216 self.zmax = self.zmax if self.zmax is not None else numpy.max(
216 217 self.z[n])
217 218 self.zmin = self.zmin if self.zmin is not None else numpy.min(
218 219 self.z[n])
219 220
220 221 if ax.firsttime:
221 222 if self.zlimits is not None:
222 223 self.zmin, self.zmax = self.zlimits[n]
223 224
224 225 ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
225 226 vmin=self.zmin,
226 227 vmax=self.zmax,
227 228 cmap=self.cmaps[n]
228 229 )
229 230 else:
230 231 if self.zlimits is not None:
231 232 self.zmin, self.zmax = self.zlimits[n]
232 233 ax.collections.remove(ax.collections[0])
233 234 ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
234 235 vmin=self.zmin,
235 236 vmax=self.zmax,
236 237 cmap=self.cmaps[n]
237 238 )
238 239
239 240
240 241 class PolarMapPlot(Plot):
241 242 '''
242 243 Plot for weather radar
243 244 '''
244 245
245 246 CODE = 'param'
246 247 colormap = 'seismic'
247 248
248 249 def setup(self):
249 250 self.ncols = 1
250 251 self.nrows = 1
251 252 self.width = 9
252 253 self.height = 8
253 254 self.mode = self.data.meta['mode']
254 255 if self.channels is not None:
255 256 self.nplots = len(self.channels)
256 257 self.nrows = len(self.channels)
257 258 else:
258 259 self.nplots = self.data.shape(self.CODE)[0]
259 260 self.nrows = self.nplots
260 261 self.channels = list(range(self.nplots))
261 262 if self.mode == 'E':
262 263 self.xlabel = 'Longitude'
263 264 self.ylabel = 'Latitude'
264 265 else:
265 266 self.xlabel = 'Range (km)'
266 267 self.ylabel = 'Height (km)'
267 268 self.bgcolor = 'white'
268 269 self.cb_labels = self.data.meta['units']
269 270 self.lat = self.data.meta['latitude']
270 271 self.lon = self.data.meta['longitude']
271 272 self.xmin, self.xmax = float(
272 273 km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
273 274 self.ymin, self.ymax = float(
274 275 km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
275 276 # self.polar = True
276 277
277 278 def plot(self):
278 279
279 280 for n, ax in enumerate(self.axes):
280 281 data = self.data['param'][self.channels[n]]
281 282
282 283 zeniths = numpy.linspace(
283 284 0, self.data.meta['max_range'], data.shape[1])
284 285 if self.mode == 'E':
285 286 azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
286 287 r, theta = numpy.meshgrid(zeniths, azimuths)
287 288 x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
288 289 theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
289 290 x = km2deg(x) + self.lon
290 291 y = km2deg(y) + self.lat
291 292 else:
292 293 azimuths = numpy.radians(self.data.yrange)
293 294 r, theta = numpy.meshgrid(zeniths, azimuths)
294 295 x, y = r*numpy.cos(theta), r*numpy.sin(theta)
295 296 self.y = zeniths
296 297
297 298 if ax.firsttime:
298 299 if self.zlimits is not None:
299 300 self.zmin, self.zmax = self.zlimits[n]
300 301 ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
301 302 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
302 303 vmin=self.zmin,
303 304 vmax=self.zmax,
304 305 cmap=self.cmaps[n])
305 306 else:
306 307 if self.zlimits is not None:
307 308 self.zmin, self.zmax = self.zlimits[n]
308 309 ax.collections.remove(ax.collections[0])
309 310 ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
310 311 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
311 312 vmin=self.zmin,
312 313 vmax=self.zmax,
313 314 cmap=self.cmaps[n])
314 315
315 316 if self.mode == 'A':
316 317 continue
317 318
318 319 # plot district names
319 320 f = open('/data/workspace/schain_scripts/distrito.csv')
320 321 for line in f:
321 322 label, lon, lat = [s.strip() for s in line.split(',') if s]
322 323 lat = float(lat)
323 324 lon = float(lon)
324 325 # ax.plot(lon, lat, '.b', ms=2)
325 326 ax.text(lon, lat, label.decode('utf8'), ha='center',
326 327 va='bottom', size='8', color='black')
327 328
328 329 # plot limites
329 330 limites = []
330 331 tmp = []
331 332 for line in open('/data/workspace/schain_scripts/lima.csv'):
332 333 if '#' in line:
333 334 if tmp:
334 335 limites.append(tmp)
335 336 tmp = []
336 337 continue
337 338 values = line.strip().split(',')
338 339 tmp.append((float(values[0]), float(values[1])))
339 340 for points in limites:
340 341 ax.add_patch(
341 342 Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
342 343
343 344 # plot Cuencas
344 345 for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
345 346 f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
346 347 values = [line.strip().split(',') for line in f]
347 348 points = [(float(s[0]), float(s[1])) for s in values]
348 349 ax.add_patch(Polygon(points, ec='b', fc='none'))
349 350
350 351 # plot grid
351 352 for r in (15, 30, 45, 60):
352 353 ax.add_artist(plt.Circle((self.lon, self.lat),
353 354 km2deg(r), color='0.6', fill=False, lw=0.2))
354 355 ax.text(
355 356 self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
356 357 self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
357 358 '{}km'.format(r),
358 359 ha='center', va='bottom', size='8', color='0.6', weight='heavy')
359 360
360 361 if self.mode == 'E':
361 362 title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
362 363 label = 'E{:02d}'.format(int(self.data.meta['elevation']))
363 364 else:
364 365 title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
365 366 label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
366 367
367 368 self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
368 369 self.titles = ['{} {}'.format(
369 370 self.data.parameters[x], title) for x in self.channels]
370 371
371 372 class WeatherPlot(Plot):
372 373 CODE = 'weather'
373 374 plot_name = 'weather'
374 375 plot_type = 'ppistyle'
375 376 buffering = False
376 377
377 378 def setup(self):
378 379 self.ncols = 1
379 380 self.nrows = 1
380 381 self.width =8
381 382 self.height =8
382 383 self.nplots= 1
383 384 self.ylabel= 'Range [Km]'
384 385 self.titles= ['Weather']
385 386 self.colorbar=False
386 387 self.ini =0
387 388 self.len_azi =0
388 389 self.buffer_ini = None
389 390 self.buffer_azi = None
390 391 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
391 392 self.flag =0
392 393 self.indicador= 0
393 394 self.last_data_azi = None
394 395 self.val_mean = None
395 396
396 397 def update(self, dataOut):
397 398
398 399 data = {}
399 400 meta = {}
400 401 if hasattr(dataOut, 'dataPP_POWER'):
401 402 factor = 1
402 403 if hasattr(dataOut, 'nFFTPoints'):
403 404 factor = dataOut.normFactor
404 405 #print("DIME EL SHAPE PORFAVOR",dataOut.data_360.shape)
405 406 data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
406 407 data['azi'] = dataOut.data_azi
407 408 data['ele'] = dataOut.data_ele
408 409 return data, meta
409 410
410 411 def get2List(self,angulos):
411 412 list1=[]
412 413 list2=[]
413 414 for i in reversed(range(len(angulos))):
414 415 diff_ = angulos[i]-angulos[i-1]
415 416 if diff_ >1.5:
416 417 list1.append(i-1)
417 418 list2.append(diff_)
418 419 return list(reversed(list1)),list(reversed(list2))
419 420
420 421 def fixData360(self,list_,ang_):
421 422 if list_[0]==-1:
422 423 vec = numpy.where(ang_<ang_[0])
423 424 ang_[vec] = ang_[vec]+360
424 425 return ang_
425 426 return ang_
426 427
427 428 def fixData360HL(self,angulos):
428 429 vec = numpy.where(angulos>=360)
429 430 angulos[vec]=angulos[vec]-360
430 431 return angulos
431 432
432 433 def search_pos(self,pos,list_):
433 434 for i in range(len(list_)):
434 435 if pos == list_[i]:
435 436 return True,i
436 437 i=None
437 438 return False,i
438 439
439 440 def fixDataComp(self,ang_,list1_,list2_):
440 441 size = len(ang_)
441 442 size2 = 0
442 443 for i in range(len(list2_)):
443 444 size2=size2+round(list2_[i])-1
444 445 new_size= size+size2
445 446 ang_new = numpy.zeros(new_size)
446 447 ang_new2 = numpy.zeros(new_size)
447 448
448 449 tmp = 0
449 450 c = 0
450 451 for i in range(len(ang_)):
451 452 ang_new[tmp +c] = ang_[i]
452 453 ang_new2[tmp+c] = ang_[i]
453 454 condition , value = self.search_pos(i,list1_)
454 455 if condition:
455 456 pos = tmp + c + 1
456 457 for k in range(round(list2_[value])-1):
457 458 ang_new[pos+k] = ang_new[pos+k-1]+1
458 459 ang_new2[pos+k] = numpy.nan
459 460 tmp = pos +k
460 461 c = 0
461 462 c=c+1
462 463 return ang_new,ang_new2
463 464
464 465 def globalCheckPED(self,angulos):
465 466 l1,l2 = self.get2List(angulos)
466 467 if len(l1)>0:
467 468 angulos2 = self.fixData360(list_=l1,ang_=angulos)
468 469 l1,l2 = self.get2List(angulos2)
469 470
470 471 ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2)
471 472 ang1_ = self.fixData360HL(ang1_)
472 473 ang2_ = self.fixData360HL(ang2_)
473 474 else:
474 475 ang1_= angulos
475 476 ang2_= angulos
476 477 return ang1_,ang2_
477 478
478 479 def analizeDATA(self,data_azi):
479 480 list1 = []
480 481 list2 = []
481 482 dat = data_azi
482 483 for i in reversed(range(1,len(dat))):
483 484 if dat[i]>dat[i-1]:
484 485 diff = int(dat[i])-int(dat[i-1])
485 486 else:
486 487 diff = 360+int(dat[i])-int(dat[i-1])
487 488 if diff > 1:
488 489 list1.append(i-1)
489 490 list2.append(diff-1)
490 491 return list1,list2
491 492
492 493 def fixDATANEW(self,data_azi,data_weather):
493 494 list1,list2 = self.analizeDATA(data_azi)
494 495 if len(list1)== 0:
495 496 return data_azi,data_weather
496 497 else:
497 498 resize = 0
498 499 for i in range(len(list2)):
499 500 resize= resize + list2[i]
500 501 new_data_azi = numpy.resize(data_azi,resize)
501 502 new_data_weather= numpy.resize(date_weather,resize)
502 503
503 504 for i in range(len(list2)):
504 505 j=0
505 506 position=list1[i]+1
506 507 for j in range(list2[i]):
507 508 new_data_azi[position+j]=new_data_azi[position+j-1]+1
508 509 return new_data_azi
509 510
510 511 def fixDATA(self,data_azi):
511 512 data=data_azi
512 513 for i in range(len(data)):
513 514 if numpy.isnan(data[i]):
514 515 data[i]=data[i-1]+1
515 516 return data
516 517
517 518 def replaceNAN(self,data_weather,data_azi,val):
518 519 data= data_azi
519 520 data_T= data_weather
520 521 if data.shape[0]> data_T.shape[0]:
521 522 data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
522 523 c = 0
523 524 for i in range(len(data)):
524 525 if numpy.isnan(data[i]):
525 526 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
526 527 else:
527 528 data_N[i,:]=data_T[c,:]
528 529 c=c+1
529 530 return data_N
530 531 else:
531 532 for i in range(len(data)):
532 533 if numpy.isnan(data[i]):
533 534 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
534 535 return data_T
535 536
536 537 def const_ploteo(self,data_weather,data_azi,step,res):
537 538 if self.ini==0:
538 539 #-------
539 540 n = (360/res)-len(data_azi)
540 541 #--------------------- new -------------------------
541 542 data_azi_new ,data_azi_old= self.globalCheckPED(data_azi)
542 543 #------------------------
543 544 start = data_azi_new[-1] + res
544 545 end = data_azi_new[0] - res
545 546 #------ new
546 547 self.last_data_azi = end
547 548 if start>end:
548 549 end = end + 360
549 550 azi_vacia = numpy.linspace(start,end,int(n))
550 551 azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia)
551 552 data_azi = numpy.hstack((data_azi_new,azi_vacia))
552 553 # RADAR
553 554 val_mean = numpy.mean(data_weather[:,-1])
554 555 self.val_mean = val_mean
555 556 data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
556 557 data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
557 558 data_weather = numpy.vstack((data_weather,data_weather_cmp))
558 559 else:
559 560 # azimuth
560 561 flag=0
561 562 start_azi = self.res_azi[0]
562 563 #-----------new------------
563 564 data_azi ,data_azi_old= self.globalCheckPED(data_azi)
564 565 data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
565 566 #--------------------------
566 567 start = data_azi[0]
567 568 end = data_azi[-1]
568 569 self.last_data_azi= end
569 570 if start< start_azi:
570 571 start = start +360
571 572 if end <start_azi:
572 573 end = end +360
573 574
574 575 pos_ini = int((start-start_azi)/res)
575 576 len_azi = len(data_azi)
576 577 if (360-pos_ini)<len_azi:
577 578 if pos_ini+1==360:
578 579 pos_ini=0
579 580 else:
580 581 flag=1
581 582 dif= 360-pos_ini
582 583 comp= len_azi-dif
583 584 #-----------------
584 585 if flag==0:
585 586 # AZIMUTH
586 587 self.res_azi[pos_ini:pos_ini+len_azi] = data_azi
587 588 # RADAR
588 589 self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather
589 590 else:
590 591 # AZIMUTH
591 592 self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif]
592 593 self.res_azi[0:comp] = data_azi[dif:]
593 594 # RADAR
594 595 self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:]
595 596 self.res_weather[0:comp,:] = data_weather[dif:,:]
596 597 flag=0
597 598 data_azi = self.res_azi
598 599 data_weather = self.res_weather
599 600
600 601 return data_weather,data_azi
601 602
602 603 def plot(self):
603 604 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
604 605 data = self.data[-1]
605 606 r = self.data.yrange
606 607 delta_height = r[1]-r[0]
607 608 r_mask = numpy.where(r>=0)[0]
608 609 r = numpy.arange(len(r_mask))*delta_height
609 610 self.y = 2*r
610 611 # RADAR
611 612 #data_weather = data['weather']
612 613 # PEDESTAL
613 614 #data_azi = data['azi']
614 615 res = 1
615 616 # STEP
616 617 step = (360/(res*data['weather'].shape[0]))
617 618
618 619 self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res)
619 620 self.res_ele = numpy.mean(data['ele'])
620 621 ################# PLOTEO ###################
621 622 for i,ax in enumerate(self.axes):
622 623 if ax.firsttime:
623 624 plt.clf()
624 625 cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=20, vmax=80)
625 626 else:
626 627 plt.clf()
627 628 cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=20, vmax=80)
628 629 caax = cgax.parasites[0]
629 630 paax = cgax.parasites[1]
630 631 cbar = plt.gcf().colorbar(pm, pad=0.075)
631 632 caax.set_xlabel('x_range [km]')
632 633 caax.set_ylabel('y_range [km]')
633 634 plt.text(1.0, 1.05, 'Azimuth '+str(thisDatetime)+" Step "+str(self.ini)+ " Elev: "+str(round(self.res_ele,2)), transform=caax.transAxes, va='bottom',ha='right')
634 635
635 636 self.ini= self.ini+1
636 637
637 638
638 639 class WeatherRHIPlot(Plot):
639 640 CODE = 'weather'
640 641 plot_name = 'weather'
641 642 plot_type = 'rhistyle'
642 643 buffering = False
643 644 data_ele_tmp = None
644 645
645 646 def setup(self):
646 647 print("********************")
647 648 print("********************")
648 649 print("********************")
649 650 print("SETUP WEATHER PLOT")
650 651 self.ncols = 1
651 652 self.nrows = 1
652 653 self.nplots= 1
653 654 self.ylabel= 'Range [Km]'
654 655 self.titles= ['Weather']
655 656 if self.channels is not None:
656 657 self.nplots = len(self.channels)
657 658 self.nrows = len(self.channels)
658 659 else:
659 660 self.nplots = self.data.shape(self.CODE)[0]
660 661 self.nrows = self.nplots
661 662 self.channels = list(range(self.nplots))
662 663 print("channels",self.channels)
663 664 print("que saldra", self.data.shape(self.CODE)[0])
664 665 self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
665 666 print("self.titles",self.titles)
666 667 self.colorbar=False
667 668 self.width =8
668 669 self.height =8
669 670 self.ini =0
670 671 self.len_azi =0
671 672 self.buffer_ini = None
672 673 self.buffer_ele = None
673 674 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
674 675 self.flag =0
675 676 self.indicador= 0
676 677 self.last_data_ele = None
677 678 self.val_mean = None
678 679
679 680 def update(self, dataOut):
680 681
681 682 data = {}
682 683 meta = {}
683 684 if hasattr(dataOut, 'dataPP_POWER'):
684 685 factor = 1
685 686 if hasattr(dataOut, 'nFFTPoints'):
686 687 factor = dataOut.normFactor
687 688 print("dataOut",dataOut.data_360.shape)
688 689 #
689 690 data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
690 691 #
691 692 #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
692 693 data['azi'] = dataOut.data_azi
693 694 data['ele'] = dataOut.data_ele
694 695 #print("UPDATE")
695 696 #print("data[weather]",data['weather'].shape)
696 697 #print("data[azi]",data['azi'])
697 698 return data, meta
698 699
699 700 def get2List(self,angulos):
700 701 list1=[]
701 702 list2=[]
702 703 for i in reversed(range(len(angulos))):
703 704 if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
704 705 diff_ = angulos[i]-angulos[i-1]
705 706 if abs(diff_) >1.5:
706 707 list1.append(i-1)
707 708 list2.append(diff_)
708 709 return list(reversed(list1)),list(reversed(list2))
709 710
710 711 def fixData90(self,list_,ang_):
711 712 if list_[0]==-1:
712 713 vec = numpy.where(ang_<ang_[0])
713 714 ang_[vec] = ang_[vec]+90
714 715 return ang_
715 716 return ang_
716 717
717 718 def fixData90HL(self,angulos):
718 719 vec = numpy.where(angulos>=90)
719 720 angulos[vec]=angulos[vec]-90
720 721 return angulos
721 722
722 723
723 724 def search_pos(self,pos,list_):
724 725 for i in range(len(list_)):
725 726 if pos == list_[i]:
726 727 return True,i
727 728 i=None
728 729 return False,i
729 730
730 731 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
731 732 size = len(ang_)
732 733 size2 = 0
733 734 for i in range(len(list2_)):
734 735 size2=size2+round(abs(list2_[i]))-1
735 736 new_size= size+size2
736 737 ang_new = numpy.zeros(new_size)
737 738 ang_new2 = numpy.zeros(new_size)
738 739
739 740 tmp = 0
740 741 c = 0
741 742 for i in range(len(ang_)):
742 743 ang_new[tmp +c] = ang_[i]
743 744 ang_new2[tmp+c] = ang_[i]
744 745 condition , value = self.search_pos(i,list1_)
745 746 if condition:
746 747 pos = tmp + c + 1
747 748 for k in range(round(abs(list2_[value]))-1):
748 749 if tipo_case==0 or tipo_case==3:#subida
749 750 ang_new[pos+k] = ang_new[pos+k-1]+1
750 751 ang_new2[pos+k] = numpy.nan
751 752 elif tipo_case==1 or tipo_case==2:#bajada
752 753 ang_new[pos+k] = ang_new[pos+k-1]-1
753 754 ang_new2[pos+k] = numpy.nan
754 755
755 756 tmp = pos +k
756 757 c = 0
757 758 c=c+1
758 759 return ang_new,ang_new2
759 760
760 761 def globalCheckPED(self,angulos,tipo_case):
761 762 l1,l2 = self.get2List(angulos)
762 763 ##print("l1",l1)
763 764 ##print("l2",l2)
764 765 if len(l1)>0:
765 766 #angulos2 = self.fixData90(list_=l1,ang_=angulos)
766 767 #l1,l2 = self.get2List(angulos2)
767 768 ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
768 769 #ang1_ = self.fixData90HL(ang1_)
769 770 #ang2_ = self.fixData90HL(ang2_)
770 771 else:
771 772 ang1_= angulos
772 773 ang2_= angulos
773 774 return ang1_,ang2_
774 775
775 776
776 777 def replaceNAN(self,data_weather,data_ele,val):
777 778 data= data_ele
778 779 data_T= data_weather
779 780 if data.shape[0]> data_T.shape[0]:
780 781 data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
781 782 c = 0
782 783 for i in range(len(data)):
783 784 if numpy.isnan(data[i]):
784 785 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
785 786 else:
786 787 data_N[i,:]=data_T[c,:]
787 788 c=c+1
788 789 return data_N
789 790 else:
790 791 for i in range(len(data)):
791 792 if numpy.isnan(data[i]):
792 793 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
793 794 return data_T
794 795
795 796 def check_case(self,data_ele,ang_max,ang_min):
796 797 start = data_ele[0]
797 798 end = data_ele[-1]
798 799 number = (end-start)
799 800 len_ang=len(data_ele)
800 801 print("start",start)
801 802 print("end",end)
802 803 print("number",number)
803 804
804 805 print("len_ang",len_ang)
805 806
806 807 #exit(1)
807 808
808 809 if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
809 810 return 0
810 811 #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
811 812 # return 1
812 813 elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
813 814 return 1
814 815 elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
815 816 return 2
816 817 elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
817 818 return 3
818 819
819 820
820 821 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min):
821 822 ang_max= ang_max
822 823 ang_min= ang_min
823 824 data_weather=data_weather
824 825 val_ch=val_ch
825 826 ##print("*********************DATA WEATHER**************************************")
826 827 ##print(data_weather)
827 828 if self.ini==0:
828 829 '''
829 830 print("**********************************************")
830 831 print("**********************************************")
831 832 print("***************ini**************")
832 833 print("**********************************************")
833 834 print("**********************************************")
834 835 '''
835 836 #print("data_ele",data_ele)
836 837 #----------------------------------------------------------
837 838 tipo_case = self.check_case(data_ele,ang_max,ang_min)
838 839 print("check_case",tipo_case)
839 840 #exit(1)
840 841 #--------------------- new -------------------------
841 842 data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
842 843
843 844 #-------------------------CAMBIOS RHI---------------------------------
844 845 start= ang_min
845 846 end = ang_max
846 847 n= (ang_max-ang_min)/res
847 848 #------ new
848 849 self.start_data_ele = data_ele_new[0]
849 850 self.end_data_ele = data_ele_new[-1]
850 851 if tipo_case==0 or tipo_case==3: # SUBIDA
851 852 n1= round(self.start_data_ele)- start
852 853 n2= end - round(self.end_data_ele)
853 854 print(self.start_data_ele)
854 855 print(self.end_data_ele)
855 856 if n1>0:
856 857 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
857 858 ele1_nan= numpy.ones(n1)*numpy.nan
858 859 data_ele = numpy.hstack((ele1,data_ele_new))
859 860 print("ele1_nan",ele1_nan.shape)
860 861 print("data_ele_old",data_ele_old.shape)
861 862 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
862 863 if n2>0:
863 864 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
864 865 ele2_nan= numpy.ones(n2)*numpy.nan
865 866 data_ele = numpy.hstack((data_ele,ele2))
866 867 print("ele2_nan",ele2_nan.shape)
867 868 print("data_ele_old",data_ele_old.shape)
868 869 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
869 870
870 871 if tipo_case==1 or tipo_case==2: # BAJADA
871 872 data_ele_new = data_ele_new[::-1] # reversa
872 873 data_ele_old = data_ele_old[::-1]# reversa
873 874 data_weather = data_weather[::-1,:]# reversa
874 875 vec= numpy.where(data_ele_new<ang_max)
875 876 data_ele_new = data_ele_new[vec]
876 877 data_ele_old = data_ele_old[vec]
877 878 data_weather = data_weather[vec[0]]
878 879 vec2= numpy.where(0<data_ele_new)
879 880 data_ele_new = data_ele_new[vec2]
880 881 data_ele_old = data_ele_old[vec2]
881 882 data_weather = data_weather[vec2[0]]
882 883 self.start_data_ele = data_ele_new[0]
883 884 self.end_data_ele = data_ele_new[-1]
884 885
885 886 n1= round(self.start_data_ele)- start
886 887 n2= end - round(self.end_data_ele)-1
887 888 print(self.start_data_ele)
888 889 print(self.end_data_ele)
889 890 if n1>0:
890 891 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
891 892 ele1_nan= numpy.ones(n1)*numpy.nan
892 893 data_ele = numpy.hstack((ele1,data_ele_new))
893 894 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
894 895 if n2>0:
895 896 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
896 897 ele2_nan= numpy.ones(n2)*numpy.nan
897 898 data_ele = numpy.hstack((data_ele,ele2))
898 899 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
899 900 # RADAR
900 901 # NOTA data_ele y data_weather es la variable que retorna
901 902 val_mean = numpy.mean(data_weather[:,-1])
902 903 self.val_mean = val_mean
903 904 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
904 905 self.data_ele_tmp[val_ch]= data_ele_old
905 906 else:
906 907 #print("**********************************************")
907 908 #print("****************VARIABLE**********************")
908 909 #-------------------------CAMBIOS RHI---------------------------------
909 910 #---------------------------------------------------------------------
910 911 ##print("INPUT data_ele",data_ele)
911 912 flag=0
912 913 start_ele = self.res_ele[0]
913 914 tipo_case = self.check_case(data_ele,ang_max,ang_min)
914 915 #print("TIPO DE DATA",tipo_case)
915 916 #-----------new------------
916 917 data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
917 918 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
918 919
919 920 #-------------------------------NEW RHI ITERATIVO-------------------------
920 921
921 922 if tipo_case==0 : # SUBIDA
922 923 vec = numpy.where(data_ele<ang_max)
923 924 data_ele = data_ele[vec]
924 925 data_ele_old = data_ele_old[vec]
925 926 data_weather = data_weather[vec[0]]
926 927
927 928 vec2 = numpy.where(0<data_ele)
928 929 data_ele= data_ele[vec2]
929 930 data_ele_old= data_ele_old[vec2]
930 931 ##print(data_ele_new)
931 932 data_weather= data_weather[vec2[0]]
932 933
933 934 new_i_ele = int(round(data_ele[0]))
934 935 new_f_ele = int(round(data_ele[-1]))
935 936 #print(new_i_ele)
936 937 #print(new_f_ele)
937 938 #print(data_ele,len(data_ele))
938 939 #print(data_ele_old,len(data_ele_old))
939 940 if new_i_ele< 2:
940 941 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
941 942 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)
942 943 self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
943 944 self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
944 945 self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
945 946 data_ele = self.res_ele
946 947 data_weather = self.res_weather[val_ch]
947 948
948 949 elif tipo_case==1 : #BAJADA
949 950 data_ele = data_ele[::-1] # reversa
950 951 data_ele_old = data_ele_old[::-1]# reversa
951 952 data_weather = data_weather[::-1,:]# reversa
952 953 vec= numpy.where(data_ele<ang_max)
953 954 data_ele = data_ele[vec]
954 955 data_ele_old = data_ele_old[vec]
955 956 data_weather = data_weather[vec[0]]
956 957 vec2= numpy.where(0<data_ele)
957 958 data_ele = data_ele[vec2]
958 959 data_ele_old = data_ele_old[vec2]
959 960 data_weather = data_weather[vec2[0]]
960 961
961 962
962 963 new_i_ele = int(round(data_ele[0]))
963 964 new_f_ele = int(round(data_ele[-1]))
964 965 #print(data_ele)
965 966 #print(ang_max)
966 967 #print(data_ele_old)
967 968 if new_i_ele <= 1:
968 969 new_i_ele = 1
969 970 if round(data_ele[-1])>=ang_max-1:
970 971 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
971 972 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)
972 973 self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
973 974 self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
974 975 self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
975 976 data_ele = self.res_ele
976 977 data_weather = self.res_weather[val_ch]
977 978
978 979 elif tipo_case==2: #bajada
979 980 vec = numpy.where(data_ele<ang_max)
980 981 data_ele = data_ele[vec]
981 982 data_weather= data_weather[vec[0]]
982 983
983 984 len_vec = len(vec)
984 985 data_ele_new = data_ele[::-1] # reversa
985 986 data_weather = data_weather[::-1,:]
986 987 new_i_ele = int(data_ele_new[0])
987 988 new_f_ele = int(data_ele_new[-1])
988 989
989 990 n1= new_i_ele- ang_min
990 991 n2= ang_max - new_f_ele-1
991 992 if n1>0:
992 993 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
993 994 ele1_nan= numpy.ones(n1)*numpy.nan
994 995 data_ele = numpy.hstack((ele1,data_ele_new))
995 996 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
996 997 if n2>0:
997 998 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
998 999 ele2_nan= numpy.ones(n2)*numpy.nan
999 1000 data_ele = numpy.hstack((data_ele,ele2))
1000 1001 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1001 1002
1002 1003 self.data_ele_tmp[val_ch] = data_ele_old
1003 1004 self.res_ele = data_ele
1004 1005 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1005 1006 data_ele = self.res_ele
1006 1007 data_weather = self.res_weather[val_ch]
1007 1008
1008 1009 elif tipo_case==3:#subida
1009 1010 vec = numpy.where(0<data_ele)
1010 1011 data_ele= data_ele[vec]
1011 1012 data_ele_new = data_ele
1012 1013 data_ele_old= data_ele_old[vec]
1013 1014 data_weather= data_weather[vec[0]]
1014 1015 pos_ini = numpy.argmin(data_ele)
1015 1016 if pos_ini>0:
1016 1017 len_vec= len(data_ele)
1017 1018 vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
1018 1019 #print(vec3)
1019 1020 data_ele= data_ele[vec3]
1020 1021 data_ele_new = data_ele
1021 1022 data_ele_old= data_ele_old[vec3]
1022 1023 data_weather= data_weather[vec3]
1023 1024
1024 1025 new_i_ele = int(data_ele_new[0])
1025 1026 new_f_ele = int(data_ele_new[-1])
1026 1027 n1= new_i_ele- ang_min
1027 1028 n2= ang_max - new_f_ele-1
1028 1029 if n1>0:
1029 1030 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
1030 1031 ele1_nan= numpy.ones(n1)*numpy.nan
1031 1032 data_ele = numpy.hstack((ele1,data_ele_new))
1032 1033 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
1033 1034 if n2>0:
1034 1035 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1035 1036 ele2_nan= numpy.ones(n2)*numpy.nan
1036 1037 data_ele = numpy.hstack((data_ele,ele2))
1037 1038 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1038 1039
1039 1040 self.data_ele_tmp[val_ch] = data_ele_old
1040 1041 self.res_ele = data_ele
1041 1042 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1042 1043 data_ele = self.res_ele
1043 1044 data_weather = self.res_weather[val_ch]
1044 1045 #print("self.data_ele_tmp",self.data_ele_tmp)
1045 1046 return data_weather,data_ele
1046 1047
1047 1048
1048 1049 def plot(self):
1049 1050 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
1050 1051 data = self.data[-1]
1051 1052 r = self.data.yrange
1052 1053 delta_height = r[1]-r[0]
1053 1054 r_mask = numpy.where(r>=0)[0]
1054 1055 ##print("delta_height",delta_height)
1055 1056 #print("r_mask",r_mask,len(r_mask))
1056 1057 r = numpy.arange(len(r_mask))*delta_height
1057 1058 self.y = 2*r
1058 1059 res = 1
1059 1060 ###print("data['weather'].shape[0]",data['weather'].shape[0])
1060 1061 ang_max = self.ang_max
1061 1062 ang_min = self.ang_min
1062 1063 var_ang =ang_max - ang_min
1063 1064 step = (int(var_ang)/(res*data['weather'].shape[0]))
1064 1065 ###print("step",step)
1065 1066 #--------------------------------------------------------
1066 1067 ##print('weather',data['weather'].shape)
1067 1068 ##print('ele',data['ele'].shape)
1068 1069
1069 1070 ###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)
1070 1071 ###self.res_azi = numpy.mean(data['azi'])
1071 1072 ###print("self.res_ele",self.res_ele)
1072 1073 plt.clf()
1073 1074 subplots = [121, 122]
1074 1075 if self.ini==0:
1075 1076 self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
1076 1077 self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
1077 1078 print("SHAPE",self.data_ele_tmp.shape)
1078 1079
1079 1080 for i,ax in enumerate(self.axes):
1080 1081 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)
1081 1082 self.res_azi = numpy.mean(data['azi'])
1082 1083 if i==0:
1083 1084 print("*****************************************************************************to plot**************************",self.res_weather[i].shape)
1084 1085 if ax.firsttime:
1085 1086 #plt.clf()
1086 1087 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)
1087 1088 #fig=self.figures[0]
1088 1089 else:
1089 1090 #plt.clf()
1090 1091 if i==0:
1091 1092 print(self.res_weather[i])
1092 1093 print(self.res_ele)
1093 1094 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)
1094 1095 caax = cgax.parasites[0]
1095 1096 paax = cgax.parasites[1]
1096 1097 cbar = plt.gcf().colorbar(pm, pad=0.075)
1097 1098 caax.set_xlabel('x_range [km]')
1098 1099 caax.set_ylabel('y_range [km]')
1099 1100 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')
1100 1101 print("***************************self.ini****************************",self.ini)
1101 1102 self.ini= self.ini+1
1102 1103
1103 1104 class WeatherRHI_vRF2_Plot(Plot):
1104 1105 CODE = 'weather'
1105 1106 plot_name = 'weather'
1106 1107 plot_type = 'rhistyle'
1107 1108 buffering = False
1108 1109 data_ele_tmp = None
1109 1110
1110 1111 def setup(self):
1111 1112 print("********************")
1112 1113 print("********************")
1113 1114 print("********************")
1114 1115 print("SETUP WEATHER PLOT")
1115 1116 self.ncols = 1
1116 1117 self.nrows = 1
1117 1118 self.nplots= 1
1118 1119 self.ylabel= 'Range [Km]'
1119 1120 self.titles= ['Weather']
1120 1121 if self.channels is not None:
1121 1122 self.nplots = len(self.channels)
1122 1123 self.nrows = len(self.channels)
1123 1124 else:
1124 1125 self.nplots = self.data.shape(self.CODE)[0]
1125 1126 self.nrows = self.nplots
1126 1127 self.channels = list(range(self.nplots))
1127 1128 print("channels",self.channels)
1128 1129 print("que saldra", self.data.shape(self.CODE)[0])
1129 1130 self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
1130 1131 print("self.titles",self.titles)
1131 1132 self.colorbar=False
1132 1133 self.width =8
1133 1134 self.height =8
1134 1135 self.ini =0
1135 1136 self.len_azi =0
1136 1137 self.buffer_ini = None
1137 1138 self.buffer_ele = None
1138 1139 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
1139 1140 self.flag =0
1140 1141 self.indicador= 0
1141 1142 self.last_data_ele = None
1142 1143 self.val_mean = None
1143 1144
1144 1145 def update(self, dataOut):
1145 1146
1146 1147 data = {}
1147 1148 meta = {}
1148 1149 if hasattr(dataOut, 'dataPP_POWER'):
1149 1150 factor = 1
1150 1151 if hasattr(dataOut, 'nFFTPoints'):
1151 1152 factor = dataOut.normFactor
1152 1153 print("dataOut",dataOut.data_360.shape)
1153 1154 #
1154 1155 data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
1155 1156 #
1156 1157 #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
1157 1158 data['azi'] = dataOut.data_azi
1158 1159 data['ele'] = dataOut.data_ele
1159 1160 data['case_flag'] = dataOut.case_flag
1160 1161 #print("UPDATE")
1161 1162 #print("data[weather]",data['weather'].shape)
1162 1163 #print("data[azi]",data['azi'])
1163 1164 return data, meta
1164 1165
1165 1166 def get2List(self,angulos):
1166 1167 list1=[]
1167 1168 list2=[]
1168 1169 for i in reversed(range(len(angulos))):
1169 1170 if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
1170 1171 diff_ = angulos[i]-angulos[i-1]
1171 1172 if abs(diff_) >1.5:
1172 1173 list1.append(i-1)
1173 1174 list2.append(diff_)
1174 1175 return list(reversed(list1)),list(reversed(list2))
1175 1176
1176 1177 def fixData90(self,list_,ang_):
1177 1178 if list_[0]==-1:
1178 1179 vec = numpy.where(ang_<ang_[0])
1179 1180 ang_[vec] = ang_[vec]+90
1180 1181 return ang_
1181 1182 return ang_
1182 1183
1183 1184 def fixData90HL(self,angulos):
1184 1185 vec = numpy.where(angulos>=90)
1185 1186 angulos[vec]=angulos[vec]-90
1186 1187 return angulos
1187 1188
1188 1189
1189 1190 def search_pos(self,pos,list_):
1190 1191 for i in range(len(list_)):
1191 1192 if pos == list_[i]:
1192 1193 return True,i
1193 1194 i=None
1194 1195 return False,i
1195 1196
1196 1197 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
1197 1198 size = len(ang_)
1198 1199 size2 = 0
1199 1200 for i in range(len(list2_)):
1200 1201 size2=size2+round(abs(list2_[i]))-1
1201 1202 new_size= size+size2
1202 1203 ang_new = numpy.zeros(new_size)
1203 1204 ang_new2 = numpy.zeros(new_size)
1204 1205
1205 1206 tmp = 0
1206 1207 c = 0
1207 1208 for i in range(len(ang_)):
1208 1209 ang_new[tmp +c] = ang_[i]
1209 1210 ang_new2[tmp+c] = ang_[i]
1210 1211 condition , value = self.search_pos(i,list1_)
1211 1212 if condition:
1212 1213 pos = tmp + c + 1
1213 1214 for k in range(round(abs(list2_[value]))-1):
1214 1215 if tipo_case==0 or tipo_case==3:#subida
1215 1216 ang_new[pos+k] = ang_new[pos+k-1]+1
1216 1217 ang_new2[pos+k] = numpy.nan
1217 1218 elif tipo_case==1 or tipo_case==2:#bajada
1218 1219 ang_new[pos+k] = ang_new[pos+k-1]-1
1219 1220 ang_new2[pos+k] = numpy.nan
1220 1221
1221 1222 tmp = pos +k
1222 1223 c = 0
1223 1224 c=c+1
1224 1225 return ang_new,ang_new2
1225 1226
1226 1227 def globalCheckPED(self,angulos,tipo_case):
1227 1228 l1,l2 = self.get2List(angulos)
1228 1229 ##print("l1",l1)
1229 1230 ##print("l2",l2)
1230 1231 if len(l1)>0:
1231 1232 #angulos2 = self.fixData90(list_=l1,ang_=angulos)
1232 1233 #l1,l2 = self.get2List(angulos2)
1233 1234 ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
1234 1235 #ang1_ = self.fixData90HL(ang1_)
1235 1236 #ang2_ = self.fixData90HL(ang2_)
1236 1237 else:
1237 1238 ang1_= angulos
1238 1239 ang2_= angulos
1239 1240 return ang1_,ang2_
1240 1241
1241 1242
1242 1243 def replaceNAN(self,data_weather,data_ele,val):
1243 1244 data= data_ele
1244 1245 data_T= data_weather
1245 1246 if data.shape[0]> data_T.shape[0]:
1246 1247 data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
1247 1248 c = 0
1248 1249 for i in range(len(data)):
1249 1250 if numpy.isnan(data[i]):
1250 1251 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
1251 1252 else:
1252 1253 data_N[i,:]=data_T[c,:]
1253 1254 c=c+1
1254 1255 return data_N
1255 1256 else:
1256 1257 for i in range(len(data)):
1257 1258 if numpy.isnan(data[i]):
1258 1259 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
1259 1260 return data_T
1260 1261
1261 1262 def check_case(self,data_ele,ang_max,ang_min):
1262 1263 start = data_ele[0]
1263 1264 end = data_ele[-1]
1264 1265 number = (end-start)
1265 1266 len_ang=len(data_ele)
1266 1267 print("start",start)
1267 1268 print("end",end)
1268 1269 print("number",number)
1269 1270
1270 1271 print("len_ang",len_ang)
1271 1272
1272 1273 #exit(1)
1273 1274
1274 1275 if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
1275 1276 return 0
1276 1277 #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
1277 1278 # return 1
1278 1279 elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
1279 1280 return 1
1280 1281 elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
1281 1282 return 2
1282 1283 elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
1283 1284 return 3
1284 1285
1285 1286
1286 1287 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min,case_flag):
1287 1288 ang_max= ang_max
1288 1289 ang_min= ang_min
1289 1290 data_weather=data_weather
1290 1291 val_ch=val_ch
1291 1292 ##print("*********************DATA WEATHER**************************************")
1292 1293 ##print(data_weather)
1293 1294 if self.ini==0:
1294 1295 '''
1295 1296 print("**********************************************")
1296 1297 print("**********************************************")
1297 1298 print("***************ini**************")
1298 1299 print("**********************************************")
1299 1300 print("**********************************************")
1300 1301 '''
1301 1302 #print("data_ele",data_ele)
1302 1303 #----------------------------------------------------------
1303 1304 tipo_case = case_flag[-1]
1304 1305 #tipo_case = self.check_case(data_ele,ang_max,ang_min)
1305 1306 print("check_case",tipo_case)
1306 1307 #exit(1)
1307 1308 #--------------------- new -------------------------
1308 1309 data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
1309 1310
1310 1311 #-------------------------CAMBIOS RHI---------------------------------
1311 1312 start= ang_min
1312 1313 end = ang_max
1313 1314 n= (ang_max-ang_min)/res
1314 1315 #------ new
1315 1316 self.start_data_ele = data_ele_new[0]
1316 1317 self.end_data_ele = data_ele_new[-1]
1317 1318 if tipo_case==0 or tipo_case==3: # SUBIDA
1318 1319 n1= round(self.start_data_ele)- start
1319 1320 n2= end - round(self.end_data_ele)
1320 1321 print(self.start_data_ele)
1321 1322 print(self.end_data_ele)
1322 1323 if n1>0:
1323 1324 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
1324 1325 ele1_nan= numpy.ones(n1)*numpy.nan
1325 1326 data_ele = numpy.hstack((ele1,data_ele_new))
1326 1327 print("ele1_nan",ele1_nan.shape)
1327 1328 print("data_ele_old",data_ele_old.shape)
1328 1329 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
1329 1330 if n2>0:
1330 1331 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
1331 1332 ele2_nan= numpy.ones(n2)*numpy.nan
1332 1333 data_ele = numpy.hstack((data_ele,ele2))
1333 1334 print("ele2_nan",ele2_nan.shape)
1334 1335 print("data_ele_old",data_ele_old.shape)
1335 1336 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1336 1337
1337 1338 if tipo_case==1 or tipo_case==2: # BAJADA
1338 1339 data_ele_new = data_ele_new[::-1] # reversa
1339 1340 data_ele_old = data_ele_old[::-1]# reversa
1340 1341 data_weather = data_weather[::-1,:]# reversa
1341 1342 vec= numpy.where(data_ele_new<ang_max)
1342 1343 data_ele_new = data_ele_new[vec]
1343 1344 data_ele_old = data_ele_old[vec]
1344 1345 data_weather = data_weather[vec[0]]
1345 1346 vec2= numpy.where(0<data_ele_new)
1346 1347 data_ele_new = data_ele_new[vec2]
1347 1348 data_ele_old = data_ele_old[vec2]
1348 1349 data_weather = data_weather[vec2[0]]
1349 1350 self.start_data_ele = data_ele_new[0]
1350 1351 self.end_data_ele = data_ele_new[-1]
1351 1352
1352 1353 n1= round(self.start_data_ele)- start
1353 1354 n2= end - round(self.end_data_ele)-1
1354 1355 print(self.start_data_ele)
1355 1356 print(self.end_data_ele)
1356 1357 if n1>0:
1357 1358 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
1358 1359 ele1_nan= numpy.ones(n1)*numpy.nan
1359 1360 data_ele = numpy.hstack((ele1,data_ele_new))
1360 1361 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
1361 1362 if n2>0:
1362 1363 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
1363 1364 ele2_nan= numpy.ones(n2)*numpy.nan
1364 1365 data_ele = numpy.hstack((data_ele,ele2))
1365 1366 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1366 1367 # RADAR
1367 1368 # NOTA data_ele y data_weather es la variable que retorna
1368 1369 val_mean = numpy.mean(data_weather[:,-1])
1369 1370 self.val_mean = val_mean
1370 1371 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1371 1372 print("eleold",data_ele_old)
1372 1373 print(self.data_ele_tmp[val_ch])
1373 1374 print(data_ele_old.shape[0])
1374 1375 print(self.data_ele_tmp[val_ch].shape[0])
1375 1376 if (data_ele_old.shape[0]==91 or self.data_ele_tmp[val_ch].shape[0]==91):
1376 1377 import sys
1377 1378 print("EXIT",self.ini)
1378 1379
1379 1380 sys.exit(1)
1380 1381 self.data_ele_tmp[val_ch]= data_ele_old
1381 1382 else:
1382 1383 #print("**********************************************")
1383 1384 #print("****************VARIABLE**********************")
1384 1385 #-------------------------CAMBIOS RHI---------------------------------
1385 1386 #---------------------------------------------------------------------
1386 1387 ##print("INPUT data_ele",data_ele)
1387 1388 flag=0
1388 1389 start_ele = self.res_ele[0]
1389 1390 #tipo_case = self.check_case(data_ele,ang_max,ang_min)
1390 1391 tipo_case = case_flag[-1]
1391 1392 #print("TIPO DE DATA",tipo_case)
1392 1393 #-----------new------------
1393 1394 data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
1394 1395 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1395 1396
1396 1397 #-------------------------------NEW RHI ITERATIVO-------------------------
1397 1398
1398 1399 if tipo_case==0 : # SUBIDA
1399 1400 vec = numpy.where(data_ele<ang_max)
1400 1401 data_ele = data_ele[vec]
1401 1402 data_ele_old = data_ele_old[vec]
1402 1403 data_weather = data_weather[vec[0]]
1403 1404
1404 1405 vec2 = numpy.where(0<data_ele)
1405 1406 data_ele= data_ele[vec2]
1406 1407 data_ele_old= data_ele_old[vec2]
1407 1408 ##print(data_ele_new)
1408 1409 data_weather= data_weather[vec2[0]]
1409 1410
1410 1411 new_i_ele = int(round(data_ele[0]))
1411 1412 new_f_ele = int(round(data_ele[-1]))
1412 1413 #print(new_i_ele)
1413 1414 #print(new_f_ele)
1414 1415 #print(data_ele,len(data_ele))
1415 1416 #print(data_ele_old,len(data_ele_old))
1416 1417 if new_i_ele< 2:
1417 1418 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
1418 1419 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)
1419 1420 self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
1420 1421 self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
1421 1422 self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
1422 1423 data_ele = self.res_ele
1423 1424 data_weather = self.res_weather[val_ch]
1424 1425
1425 1426 elif tipo_case==1 : #BAJADA
1426 1427 data_ele = data_ele[::-1] # reversa
1427 1428 data_ele_old = data_ele_old[::-1]# reversa
1428 1429 data_weather = data_weather[::-1,:]# reversa
1429 1430 vec= numpy.where(data_ele<ang_max)
1430 1431 data_ele = data_ele[vec]
1431 1432 data_ele_old = data_ele_old[vec]
1432 1433 data_weather = data_weather[vec[0]]
1433 1434 vec2= numpy.where(0<data_ele)
1434 1435 data_ele = data_ele[vec2]
1435 1436 data_ele_old = data_ele_old[vec2]
1436 1437 data_weather = data_weather[vec2[0]]
1437 1438
1438 1439
1439 1440 new_i_ele = int(round(data_ele[0]))
1440 1441 new_f_ele = int(round(data_ele[-1]))
1441 1442 #print(data_ele)
1442 1443 #print(ang_max)
1443 1444 #print(data_ele_old)
1444 1445 if new_i_ele <= 1:
1445 1446 new_i_ele = 1
1446 1447 if round(data_ele[-1])>=ang_max-1:
1447 1448 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
1448 1449 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)
1449 1450 self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
1450 1451 self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
1451 1452 self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
1452 1453 data_ele = self.res_ele
1453 1454 data_weather = self.res_weather[val_ch]
1454 1455
1455 1456 elif tipo_case==2: #bajada
1456 1457 vec = numpy.where(data_ele<ang_max)
1457 1458 data_ele = data_ele[vec]
1458 1459 data_weather= data_weather[vec[0]]
1459 1460
1460 1461 len_vec = len(vec)
1461 1462 data_ele_new = data_ele[::-1] # reversa
1462 1463 data_weather = data_weather[::-1,:]
1463 1464 new_i_ele = int(data_ele_new[0])
1464 1465 new_f_ele = int(data_ele_new[-1])
1465 1466
1466 1467 n1= new_i_ele- ang_min
1467 1468 n2= ang_max - new_f_ele-1
1468 1469 if n1>0:
1469 1470 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
1470 1471 ele1_nan= numpy.ones(n1)*numpy.nan
1471 1472 data_ele = numpy.hstack((ele1,data_ele_new))
1472 1473 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
1473 1474 if n2>0:
1474 1475 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1475 1476 ele2_nan= numpy.ones(n2)*numpy.nan
1476 1477 data_ele = numpy.hstack((data_ele,ele2))
1477 1478 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1478 1479
1479 1480 self.data_ele_tmp[val_ch] = data_ele_old
1480 1481 self.res_ele = data_ele
1481 1482 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1482 1483 data_ele = self.res_ele
1483 1484 data_weather = self.res_weather[val_ch]
1484 1485
1485 1486 elif tipo_case==3:#subida
1486 1487 vec = numpy.where(0<data_ele)
1487 1488 data_ele= data_ele[vec]
1488 1489 data_ele_new = data_ele
1489 1490 data_ele_old= data_ele_old[vec]
1490 1491 data_weather= data_weather[vec[0]]
1491 1492 pos_ini = numpy.argmin(data_ele)
1492 1493 if pos_ini>0:
1493 1494 len_vec= len(data_ele)
1494 1495 vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
1495 1496 #print(vec3)
1496 1497 data_ele= data_ele[vec3]
1497 1498 data_ele_new = data_ele
1498 1499 data_ele_old= data_ele_old[vec3]
1499 1500 data_weather= data_weather[vec3]
1500 1501
1501 1502 new_i_ele = int(data_ele_new[0])
1502 1503 new_f_ele = int(data_ele_new[-1])
1503 1504 n1= new_i_ele- ang_min
1504 1505 n2= ang_max - new_f_ele-1
1505 1506 if n1>0:
1506 1507 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
1507 1508 ele1_nan= numpy.ones(n1)*numpy.nan
1508 1509 data_ele = numpy.hstack((ele1,data_ele_new))
1509 1510 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
1510 1511 if n2>0:
1511 1512 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1512 1513 ele2_nan= numpy.ones(n2)*numpy.nan
1513 1514 data_ele = numpy.hstack((data_ele,ele2))
1514 1515 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1515 1516
1516 1517 self.data_ele_tmp[val_ch] = data_ele_old
1517 1518 self.res_ele = data_ele
1518 1519 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1519 1520 data_ele = self.res_ele
1520 1521 data_weather = self.res_weather[val_ch]
1521 1522 #print("self.data_ele_tmp",self.data_ele_tmp)
1522 1523 return data_weather,data_ele
1523 1524
1524 1525
1525 1526 def plot(self):
1526 1527 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
1527 1528 data = self.data[-1]
1528 1529 r = self.data.yrange
1529 1530 delta_height = r[1]-r[0]
1530 1531 r_mask = numpy.where(r>=0)[0]
1531 1532 ##print("delta_height",delta_height)
1532 1533 #print("r_mask",r_mask,len(r_mask))
1533 1534 r = numpy.arange(len(r_mask))*delta_height
1534 1535 self.y = 2*r
1535 1536 res = 1
1536 1537 ###print("data['weather'].shape[0]",data['weather'].shape[0])
1537 1538 ang_max = self.ang_max
1538 1539 ang_min = self.ang_min
1539 1540 var_ang =ang_max - ang_min
1540 1541 step = (int(var_ang)/(res*data['weather'].shape[0]))
1541 1542 ###print("step",step)
1542 1543 #--------------------------------------------------------
1543 1544 ##print('weather',data['weather'].shape)
1544 1545 ##print('ele',data['ele'].shape)
1545 1546
1546 1547 ###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)
1547 1548 ###self.res_azi = numpy.mean(data['azi'])
1548 1549 ###print("self.res_ele",self.res_ele)
1549 1550 plt.clf()
1550 1551 subplots = [121, 122]
1551 1552 try:
1552 1553 if self.data[-2]['ele'].max()<data['ele'].max():
1553 1554 self.ini=0
1554 1555 except:
1555 1556 pass
1556 1557 if self.ini==0:
1557 1558 self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
1558 1559 self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
1559 1560 print("SHAPE",self.data_ele_tmp.shape)
1560 1561
1561 1562 for i,ax in enumerate(self.axes):
1562 1563 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'])
1563 1564 self.res_azi = numpy.mean(data['azi'])
1564 1565
1565 1566 if ax.firsttime:
1566 1567 #plt.clf()
1567 1568 print("Frist Plot")
1568 1569 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)
1569 1570 #fig=self.figures[0]
1570 1571 else:
1571 1572 #plt.clf()
1572 1573 print("ELSE PLOT")
1573 1574 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)
1574 1575 caax = cgax.parasites[0]
1575 1576 paax = cgax.parasites[1]
1576 1577 cbar = plt.gcf().colorbar(pm, pad=0.075)
1577 1578 caax.set_xlabel('x_range [km]')
1578 1579 caax.set_ylabel('y_range [km]')
1579 1580 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')
1580 1581 print("***************************self.ini****************************",self.ini)
1581 1582 self.ini= self.ini+1
1582 1583
1583 1584 class WeatherRHI_vRF_Plot(Plot):
1584 1585 CODE = 'weather'
1585 1586 plot_name = 'weather'
1586 1587 plot_type = 'rhistyle'
1587 1588 buffering = False
1588 1589 data_ele_tmp = None
1589 1590
1590 1591 def setup(self):
1591 1592 print("********************")
1592 1593 print("********************")
1593 1594 print("********************")
1594 1595 print("SETUP WEATHER PLOT")
1595 1596 self.ncols = 1
1596 1597 self.nrows = 1
1597 1598 self.nplots= 1
1598 1599 self.ylabel= 'Range [Km]'
1599 1600 self.titles= ['Weather']
1600 1601 if self.channels is not None:
1601 1602 self.nplots = len(self.channels)
1602 1603 self.nrows = len(self.channels)
1603 1604 else:
1604 1605 self.nplots = self.data.shape(self.CODE)[0]
1605 1606 self.nrows = self.nplots
1606 1607 self.channels = list(range(self.nplots))
1607 1608 print("channels",self.channels)
1608 1609 print("que saldra", self.data.shape(self.CODE)[0])
1609 1610 self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
1610 1611 print("self.titles",self.titles)
1611 1612 self.colorbar=False
1612 1613 self.width =8
1613 1614 self.height =8
1614 1615 self.ini =0
1615 1616 self.len_azi =0
1616 1617 self.buffer_ini = None
1617 1618 self.buffer_ele = None
1618 1619 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
1619 1620 self.flag =0
1620 1621 self.indicador= 0
1621 1622 self.last_data_ele = None
1622 1623 self.val_mean = None
1623 1624
1624 1625 def update(self, dataOut):
1625 1626
1626 1627 data = {}
1627 1628 meta = {}
1628 1629 if hasattr(dataOut, 'dataPP_POWER'):
1629 1630 factor = 1
1630 1631 if hasattr(dataOut, 'nFFTPoints'):
1631 1632 factor = dataOut.normFactor
1632 1633 print("dataOut",dataOut.data_360.shape)
1633 1634 #
1634 1635 data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
1635 1636 #
1636 1637 #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
1637 1638 data['azi'] = dataOut.data_azi
1638 1639 data['ele'] = dataOut.data_ele
1639 1640 data['case_flag'] = dataOut.case_flag
1640 1641 #print("UPDATE")
1641 1642 #print("data[weather]",data['weather'].shape)
1642 1643 #print("data[azi]",data['azi'])
1643 1644 return data, meta
1644 1645
1645 1646 def get2List(self,angulos):
1646 1647 list1=[]
1647 1648 list2=[]
1648 1649 #print(angulos)
1649 1650 #exit(1)
1650 1651 for i in reversed(range(len(angulos))):
1651 1652 if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
1652 1653 diff_ = angulos[i]-angulos[i-1]
1653 1654 if abs(diff_) >1.5:
1654 1655 list1.append(i-1)
1655 1656 list2.append(diff_)
1656 1657 return list(reversed(list1)),list(reversed(list2))
1657 1658
1658 1659 def fixData90(self,list_,ang_):
1659 1660 if list_[0]==-1:
1660 1661 vec = numpy.where(ang_<ang_[0])
1661 1662 ang_[vec] = ang_[vec]+90
1662 1663 return ang_
1663 1664 return ang_
1664 1665
1665 1666 def fixData90HL(self,angulos):
1666 1667 vec = numpy.where(angulos>=90)
1667 1668 angulos[vec]=angulos[vec]-90
1668 1669 return angulos
1669 1670
1670 1671
1671 1672 def search_pos(self,pos,list_):
1672 1673 for i in range(len(list_)):
1673 1674 if pos == list_[i]:
1674 1675 return True,i
1675 1676 i=None
1676 1677 return False,i
1677 1678
1678 1679 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
1679 1680 size = len(ang_)
1680 1681 size2 = 0
1681 1682 for i in range(len(list2_)):
1682 1683 size2=size2+round(abs(list2_[i]))-1
1683 1684 new_size= size+size2
1684 1685 ang_new = numpy.zeros(new_size)
1685 1686 ang_new2 = numpy.zeros(new_size)
1686 1687
1687 1688 tmp = 0
1688 1689 c = 0
1689 1690 for i in range(len(ang_)):
1690 1691 ang_new[tmp +c] = ang_[i]
1691 1692 ang_new2[tmp+c] = ang_[i]
1692 1693 condition , value = self.search_pos(i,list1_)
1693 1694 if condition:
1694 1695 pos = tmp + c + 1
1695 1696 for k in range(round(abs(list2_[value]))-1):
1696 1697 if tipo_case==0 or tipo_case==3:#subida
1697 1698 ang_new[pos+k] = ang_new[pos+k-1]+1
1698 1699 ang_new2[pos+k] = numpy.nan
1699 1700 elif tipo_case==1 or tipo_case==2:#bajada
1700 1701 ang_new[pos+k] = ang_new[pos+k-1]-1
1701 1702 ang_new2[pos+k] = numpy.nan
1702 1703
1703 1704 tmp = pos +k
1704 1705 c = 0
1705 1706 c=c+1
1706 1707 return ang_new,ang_new2
1707 1708
1708 1709 def globalCheckPED(self,angulos,tipo_case):
1709 1710 l1,l2 = self.get2List(angulos)
1710 1711 print("l1",l1)
1711 1712 print("l2",l2)
1712 1713 if len(l1)>0:
1713 1714 #angulos2 = self.fixData90(list_=l1,ang_=angulos)
1714 1715 #l1,l2 = self.get2List(angulos2)
1715 1716 ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
1716 1717 #ang1_ = self.fixData90HL(ang1_)
1717 1718 #ang2_ = self.fixData90HL(ang2_)
1718 1719 else:
1719 1720 ang1_= angulos
1720 1721 ang2_= angulos
1721 1722 return ang1_,ang2_
1722 1723
1723 1724
1724 1725 def replaceNAN(self,data_weather,data_ele,val):
1725 1726 data= data_ele
1726 1727 data_T= data_weather
1727 1728 #print(data.shape[0])
1728 1729 #print(data_T.shape[0])
1729 1730 #exit(1)
1730 1731 if data.shape[0]> data_T.shape[0]:
1731 1732 data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
1732 1733 c = 0
1733 1734 for i in range(len(data)):
1734 1735 if numpy.isnan(data[i]):
1735 1736 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
1736 1737 else:
1737 1738 data_N[i,:]=data_T[c,:]
1738 1739 c=c+1
1739 1740 return data_N
1740 1741 else:
1741 1742 for i in range(len(data)):
1742 1743 if numpy.isnan(data[i]):
1743 1744 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
1744 1745 return data_T
1745 1746
1746 1747
1747 1748 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min,case_flag):
1748 1749 ang_max= ang_max
1749 1750 ang_min= ang_min
1750 1751 data_weather=data_weather
1751 1752 val_ch=val_ch
1752 1753 ##print("*********************DATA WEATHER**************************************")
1753 1754 ##print(data_weather)
1754 1755
1755 1756 '''
1756 1757 print("**********************************************")
1757 1758 print("**********************************************")
1758 1759 print("***************ini**************")
1759 1760 print("**********************************************")
1760 1761 print("**********************************************")
1761 1762 '''
1762 1763 #print("data_ele",data_ele)
1763 1764 #----------------------------------------------------------
1764 1765
1765 1766 #exit(1)
1766 1767 tipo_case = case_flag[-1]
1767 1768 print("tipo_case",tipo_case)
1768 1769 #--------------------- new -------------------------
1769 1770 data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
1770 1771
1771 1772 #-------------------------CAMBIOS RHI---------------------------------
1772 1773
1773 1774 vec = numpy.where(data_ele<ang_max)
1774 1775 data_ele = data_ele[vec]
1775 1776 data_weather= data_weather[vec[0]]
1776 1777
1777 1778 len_vec = len(vec)
1778 1779 data_ele_new = data_ele[::-1] # reversa
1779 1780 data_weather = data_weather[::-1,:]
1780 1781 new_i_ele = int(data_ele_new[0])
1781 1782 new_f_ele = int(data_ele_new[-1])
1782 1783
1783 1784 n1= new_i_ele- ang_min
1784 1785 n2= ang_max - new_f_ele-1
1785 1786 if n1>0:
1786 1787 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
1787 1788 ele1_nan= numpy.ones(n1)*numpy.nan
1788 1789 data_ele = numpy.hstack((ele1,data_ele_new))
1789 1790 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
1790 1791 if n2>0:
1791 1792 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1792 1793 ele2_nan= numpy.ones(n2)*numpy.nan
1793 1794 data_ele = numpy.hstack((data_ele,ele2))
1794 1795 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1795 1796
1796 1797
1797 1798 print("ele shape",data_ele.shape)
1798 1799 print(data_ele)
1799 1800
1800 1801 #print("self.data_ele_tmp",self.data_ele_tmp)
1801 1802 val_mean = numpy.mean(data_weather[:,-1])
1802 1803 self.val_mean = val_mean
1803 1804 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1804 1805 self.data_ele_tmp[val_ch]= data_ele_old
1805 1806
1806 1807
1807 1808 print("data_weather shape",data_weather.shape)
1808 1809 print(data_weather)
1809 1810 #exit(1)
1810 1811 return data_weather,data_ele
1811 1812
1812 1813
1813 1814 def plot(self):
1814 1815 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
1815 1816 data = self.data[-1]
1816 1817 r = self.data.yrange
1817 1818 delta_height = r[1]-r[0]
1818 1819 r_mask = numpy.where(r>=0)[0]
1819 1820 ##print("delta_height",delta_height)
1820 1821 #print("r_mask",r_mask,len(r_mask))
1821 1822 r = numpy.arange(len(r_mask))*delta_height
1822 1823 self.y = 2*r
1823 1824 res = 1
1824 1825 ###print("data['weather'].shape[0]",data['weather'].shape[0])
1825 1826 ang_max = self.ang_max
1826 1827 ang_min = self.ang_min
1827 1828 var_ang =ang_max - ang_min
1828 1829 step = (int(var_ang)/(res*data['weather'].shape[0]))
1829 1830 ###print("step",step)
1830 1831 #--------------------------------------------------------
1831 1832 ##print('weather',data['weather'].shape)
1832 1833 ##print('ele',data['ele'].shape)
1833 1834
1834 1835 ###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)
1835 1836 ###self.res_azi = numpy.mean(data['azi'])
1836 1837 ###print("self.res_ele",self.res_ele)
1837 1838 plt.clf()
1838 1839 subplots = [121, 122]
1839 1840 if self.ini==0:
1840 1841 self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
1841 1842 self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
1842 1843 print("SHAPE",self.data_ele_tmp.shape)
1843 1844
1844 1845 for i,ax in enumerate(self.axes):
1845 1846 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'])
1846 1847 self.res_azi = numpy.mean(data['azi'])
1847 1848
1848 1849 print(self.res_ele)
1849 1850 #exit(1)
1850 1851 if ax.firsttime:
1851 1852 #plt.clf()
1852 1853 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)
1853 1854 #fig=self.figures[0]
1854 1855 else:
1855 1856
1856 1857 #plt.clf()
1857 1858 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)
1858 1859 caax = cgax.parasites[0]
1859 1860 paax = cgax.parasites[1]
1860 1861 cbar = plt.gcf().colorbar(pm, pad=0.075)
1861 1862 caax.set_xlabel('x_range [km]')
1862 1863 caax.set_ylabel('y_range [km]')
1863 1864 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')
1864 1865 print("***************************self.ini****************************",self.ini)
1865 1866 self.ini= self.ini+1
1867
1868 class WeatherRHI_vRF3_Plot(Plot):
1869 CODE = 'weather'
1870 plot_name = 'weather'
1871 plot_type = 'rhistyle'
1872 buffering = False
1873 data_ele_tmp = None
1874
1875 def setup(self):
1876 print("********************")
1877 print("********************")
1878 print("********************")
1879 print("SETUP WEATHER PLOT")
1880 self.ncols = 1
1881 self.nrows = 1
1882 self.nplots= 1
1883 self.ylabel= 'Range [Km]'
1884 self.titles= ['Weather']
1885 if self.channels is not None:
1886 self.nplots = len(self.channels)
1887 self.nrows = len(self.channels)
1888 else:
1889 self.nplots = self.data.shape(self.CODE)[0]
1890 self.nrows = self.nplots
1891 self.channels = list(range(self.nplots))
1892 print("channels",self.channels)
1893 print("que saldra", self.data.shape(self.CODE)[0])
1894 self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
1895 print("self.titles",self.titles)
1896 self.colorbar=False
1897 self.width =8
1898 self.height =8
1899 self.ini =0
1900 self.len_azi =0
1901 self.buffer_ini = None
1902 self.buffer_ele = None
1903 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
1904 self.flag =0
1905 self.indicador= 0
1906 self.last_data_ele = None
1907 self.val_mean = None
1908
1909 def update(self, dataOut):
1910
1911 data = {}
1912 meta = {}
1913 if hasattr(dataOut, 'dataPP_POWER'):
1914 factor = 1
1915 if hasattr(dataOut, 'nFFTPoints'):
1916 factor = dataOut.normFactor
1917 print("dataOut",dataOut.data_360.shape)
1918 #
1919 data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
1920 #
1921 #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
1922 data['azi'] = dataOut.data_azi
1923 data['ele'] = dataOut.data_ele
1924 #data['case_flag'] = dataOut.case_flag
1925 #print("UPDATE")
1926 #print("data[weather]",data['weather'].shape)
1927 #print("data[azi]",data['azi'])
1928 return data, meta
1929
1930 def get2List(self,angulos):
1931 list1=[]
1932 list2=[]
1933 for i in reversed(range(len(angulos))):
1934 if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
1935 diff_ = angulos[i]-angulos[i-1]
1936 if abs(diff_) >1.5:
1937 list1.append(i-1)
1938 list2.append(diff_)
1939 return list(reversed(list1)),list(reversed(list2))
1940
1941 def fixData90(self,list_,ang_):
1942 if list_[0]==-1:
1943 vec = numpy.where(ang_<ang_[0])
1944 ang_[vec] = ang_[vec]+90
1945 return ang_
1946 return ang_
1947
1948 def fixData90HL(self,angulos):
1949 vec = numpy.where(angulos>=90)
1950 angulos[vec]=angulos[vec]-90
1951 return angulos
1952
1953
1954 def search_pos(self,pos,list_):
1955 for i in range(len(list_)):
1956 if pos == list_[i]:
1957 return True,i
1958 i=None
1959 return False,i
1960
1961 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
1962 size = len(ang_)
1963 size2 = 0
1964 for i in range(len(list2_)):
1965 size2=size2+round(abs(list2_[i]))-1
1966 new_size= size+size2
1967 ang_new = numpy.zeros(new_size)
1968 ang_new2 = numpy.zeros(new_size)
1969
1970 tmp = 0
1971 c = 0
1972 for i in range(len(ang_)):
1973 ang_new[tmp +c] = ang_[i]
1974 ang_new2[tmp+c] = ang_[i]
1975 condition , value = self.search_pos(i,list1_)
1976 if condition:
1977 pos = tmp + c + 1
1978 for k in range(round(abs(list2_[value]))-1):
1979 if tipo_case==0 or tipo_case==3:#subida
1980 ang_new[pos+k] = ang_new[pos+k-1]+1
1981 ang_new2[pos+k] = numpy.nan
1982 elif tipo_case==1 or tipo_case==2:#bajada
1983 ang_new[pos+k] = ang_new[pos+k-1]-1
1984 ang_new2[pos+k] = numpy.nan
1985
1986 tmp = pos +k
1987 c = 0
1988 c=c+1
1989 return ang_new,ang_new2
1990
1991 def globalCheckPED(self,angulos,tipo_case):
1992 l1,l2 = self.get2List(angulos)
1993 ##print("l1",l1)
1994 ##print("l2",l2)
1995 if len(l1)>0:
1996 #angulos2 = self.fixData90(list_=l1,ang_=angulos)
1997 #l1,l2 = self.get2List(angulos2)
1998 ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
1999 #ang1_ = self.fixData90HL(ang1_)
2000 #ang2_ = self.fixData90HL(ang2_)
2001 else:
2002 ang1_= angulos
2003 ang2_= angulos
2004 return ang1_,ang2_
2005
2006
2007 def replaceNAN(self,data_weather,data_ele,val):
2008 data= data_ele
2009 data_T= data_weather
2010
2011 if data.shape[0]> data_T.shape[0]:
2012 print("IF")
2013 data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
2014 c = 0
2015 for i in range(len(data)):
2016 if numpy.isnan(data[i]):
2017 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
2018 else:
2019 data_N[i,:]=data_T[c,:]
2020 c=c+1
2021 return data_N
2022 else:
2023 print("else")
2024 for i in range(len(data)):
2025 if numpy.isnan(data[i]):
2026 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
2027 return data_T
2028
2029 def check_case(self,data_ele,ang_max,ang_min):
2030 start = data_ele[0]
2031 end = data_ele[-1]
2032 number = (end-start)
2033 len_ang=len(data_ele)
2034 print("start",start)
2035 print("end",end)
2036 print("number",number)
2037
2038 print("len_ang",len_ang)
2039
2040 #exit(1)
2041
2042 if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
2043 return 0
2044 #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
2045 # return 1
2046 elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
2047 return 1
2048 elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
2049 return 2
2050 elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
2051 return 3
2052
2053
2054 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min,case_flag):
2055 ang_max= ang_max
2056 ang_min= ang_min
2057 data_weather=data_weather
2058 val_ch=val_ch
2059 ##print("*********************DATA WEATHER**************************************")
2060 ##print(data_weather)
2061 if self.ini==0:
2062
2063 #--------------------- new -------------------------
2064 data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
2065
2066 #-------------------------CAMBIOS RHI---------------------------------
2067 start= ang_min
2068 end = ang_max
2069 n= (ang_max-ang_min)/res
2070 #------ new
2071 self.start_data_ele = data_ele_new[0]
2072 self.end_data_ele = data_ele_new[-1]
2073 if tipo_case==0 or tipo_case==3: # SUBIDA
2074 n1= round(self.start_data_ele)- start
2075 n2= end - round(self.end_data_ele)
2076 print(self.start_data_ele)
2077 print(self.end_data_ele)
2078 if n1>0:
2079 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
2080 ele1_nan= numpy.ones(n1)*numpy.nan
2081 data_ele = numpy.hstack((ele1,data_ele_new))
2082 print("ele1_nan",ele1_nan.shape)
2083 print("data_ele_old",data_ele_old.shape)
2084 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
2085 if n2>0:
2086 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
2087 ele2_nan= numpy.ones(n2)*numpy.nan
2088 data_ele = numpy.hstack((data_ele,ele2))
2089 print("ele2_nan",ele2_nan.shape)
2090 print("data_ele_old",data_ele_old.shape)
2091 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
2092
2093 if tipo_case==1 or tipo_case==2: # BAJADA
2094 data_ele_new = data_ele_new[::-1] # reversa
2095 data_ele_old = data_ele_old[::-1]# reversa
2096 data_weather = data_weather[::-1,:]# reversa
2097 vec= numpy.where(data_ele_new<ang_max)
2098 data_ele_new = data_ele_new[vec]
2099 data_ele_old = data_ele_old[vec]
2100 data_weather = data_weather[vec[0]]
2101 vec2= numpy.where(0<data_ele_new)
2102 data_ele_new = data_ele_new[vec2]
2103 data_ele_old = data_ele_old[vec2]
2104 data_weather = data_weather[vec2[0]]
2105 self.start_data_ele = data_ele_new[0]
2106 self.end_data_ele = data_ele_new[-1]
2107
2108 n1= round(self.start_data_ele)- start
2109 n2= end - round(self.end_data_ele)-1
2110 print(self.start_data_ele)
2111 print(self.end_data_ele)
2112 if n1>0:
2113 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
2114 ele1_nan= numpy.ones(n1)*numpy.nan
2115 data_ele = numpy.hstack((ele1,data_ele_new))
2116 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
2117 if n2>0:
2118 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
2119 ele2_nan= numpy.ones(n2)*numpy.nan
2120 data_ele = numpy.hstack((data_ele,ele2))
2121 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
2122 # RADAR
2123 # NOTA data_ele y data_weather es la variable que retorna
2124 val_mean = numpy.mean(data_weather[:,-1])
2125 self.val_mean = val_mean
2126 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
2127 print("eleold",data_ele_old)
2128 print(self.data_ele_tmp[val_ch])
2129 print(data_ele_old.shape[0])
2130 print(self.data_ele_tmp[val_ch].shape[0])
2131 if (data_ele_old.shape[0]==91 or self.data_ele_tmp[val_ch].shape[0]==91):
2132 import sys
2133 print("EXIT",self.ini)
2134
2135 sys.exit(1)
2136 self.data_ele_tmp[val_ch]= data_ele_old
2137 else:
2138 #print("**********************************************")
2139 #print("****************VARIABLE**********************")
2140 #-------------------------CAMBIOS RHI---------------------------------
2141 #---------------------------------------------------------------------
2142 ##print("INPUT data_ele",data_ele)
2143 flag=0
2144 start_ele = self.res_ele[0]
2145 #tipo_case = self.check_case(data_ele,ang_max,ang_min)
2146 tipo_case = case_flag[-1]
2147 #print("TIPO DE DATA",tipo_case)
2148 #-----------new------------
2149 data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
2150 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
2151
2152 #-------------------------------NEW RHI ITERATIVO-------------------------
2153
2154 if tipo_case==0 : # SUBIDA
2155 vec = numpy.where(data_ele<ang_max)
2156 data_ele = data_ele[vec]
2157 data_ele_old = data_ele_old[vec]
2158 data_weather = data_weather[vec[0]]
2159
2160 vec2 = numpy.where(0<data_ele)
2161 data_ele= data_ele[vec2]
2162 data_ele_old= data_ele_old[vec2]
2163 ##print(data_ele_new)
2164 data_weather= data_weather[vec2[0]]
2165
2166 new_i_ele = int(round(data_ele[0]))
2167 new_f_ele = int(round(data_ele[-1]))
2168 #print(new_i_ele)
2169 #print(new_f_ele)
2170 #print(data_ele,len(data_ele))
2171 #print(data_ele_old,len(data_ele_old))
2172 if new_i_ele< 2:
2173 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
2174 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)
2175 self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
2176 self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
2177 self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
2178 data_ele = self.res_ele
2179 data_weather = self.res_weather[val_ch]
2180
2181 elif tipo_case==1 : #BAJADA
2182 data_ele = data_ele[::-1] # reversa
2183 data_ele_old = data_ele_old[::-1]# reversa
2184 data_weather = data_weather[::-1,:]# reversa
2185 vec= numpy.where(data_ele<ang_max)
2186 data_ele = data_ele[vec]
2187 data_ele_old = data_ele_old[vec]
2188 data_weather = data_weather[vec[0]]
2189 vec2= numpy.where(0<data_ele)
2190 data_ele = data_ele[vec2]
2191 data_ele_old = data_ele_old[vec2]
2192 data_weather = data_weather[vec2[0]]
2193
2194
2195 new_i_ele = int(round(data_ele[0]))
2196 new_f_ele = int(round(data_ele[-1]))
2197 #print(data_ele)
2198 #print(ang_max)
2199 #print(data_ele_old)
2200 if new_i_ele <= 1:
2201 new_i_ele = 1
2202 if round(data_ele[-1])>=ang_max-1:
2203 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
2204 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)
2205 self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
2206 self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
2207 self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
2208 data_ele = self.res_ele
2209 data_weather = self.res_weather[val_ch]
2210
2211 elif tipo_case==2: #bajada
2212 vec = numpy.where(data_ele<ang_max)
2213 data_ele = data_ele[vec]
2214 data_weather= data_weather[vec[0]]
2215
2216 len_vec = len(vec)
2217 data_ele_new = data_ele[::-1] # reversa
2218 data_weather = data_weather[::-1,:]
2219 new_i_ele = int(data_ele_new[0])
2220 new_f_ele = int(data_ele_new[-1])
2221
2222 n1= new_i_ele- ang_min
2223 n2= ang_max - new_f_ele-1
2224 if n1>0:
2225 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
2226 ele1_nan= numpy.ones(n1)*numpy.nan
2227 data_ele = numpy.hstack((ele1,data_ele_new))
2228 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
2229 if n2>0:
2230 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
2231 ele2_nan= numpy.ones(n2)*numpy.nan
2232 data_ele = numpy.hstack((data_ele,ele2))
2233 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
2234
2235 self.data_ele_tmp[val_ch] = data_ele_old
2236 self.res_ele = data_ele
2237 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
2238 data_ele = self.res_ele
2239 data_weather = self.res_weather[val_ch]
2240
2241 elif tipo_case==3:#subida
2242 vec = numpy.where(0<data_ele)
2243 data_ele= data_ele[vec]
2244 data_ele_new = data_ele
2245 data_ele_old= data_ele_old[vec]
2246 data_weather= data_weather[vec[0]]
2247 pos_ini = numpy.argmin(data_ele)
2248 if pos_ini>0:
2249 len_vec= len(data_ele)
2250 vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
2251 #print(vec3)
2252 data_ele= data_ele[vec3]
2253 data_ele_new = data_ele
2254 data_ele_old= data_ele_old[vec3]
2255 data_weather= data_weather[vec3]
2256
2257 new_i_ele = int(data_ele_new[0])
2258 new_f_ele = int(data_ele_new[-1])
2259 n1= new_i_ele- ang_min
2260 n2= ang_max - new_f_ele-1
2261 if n1>0:
2262 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
2263 ele1_nan= numpy.ones(n1)*numpy.nan
2264 data_ele = numpy.hstack((ele1,data_ele_new))
2265 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
2266 if n2>0:
2267 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
2268 ele2_nan= numpy.ones(n2)*numpy.nan
2269 data_ele = numpy.hstack((data_ele,ele2))
2270 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
2271
2272 self.data_ele_tmp[val_ch] = data_ele_old
2273 self.res_ele = data_ele
2274 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
2275 data_ele = self.res_ele
2276 data_weather = self.res_weather[val_ch]
2277 #print("self.data_ele_tmp",self.data_ele_tmp)
2278 return data_weather,data_ele
2279
2280 def const_ploteo_vRF(self,val_ch,data_weather,data_ele,res,ang_max,ang_min):
2281
2282 data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,1)
2283
2284 data_ele = data_ele_old.copy()
2285
2286 diff_1 = ang_max - data_ele[0]
2287 angles_1_nan = numpy.linspace(ang_max,data_ele[0]+1,int(diff_1)-1)#*numpy.nan
2288
2289 diff_2 = data_ele[-1]-ang_min
2290 angles_2_nan = numpy.linspace(data_ele[-1]-1,ang_min,int(diff_2)-1)#*numpy.nan
2291
2292 angles_filled = numpy.concatenate((angles_1_nan,data_ele,angles_2_nan))
2293
2294 print(angles_filled)
2295
2296 data_1_nan = numpy.ones([angles_1_nan.shape[0],len(self.r_mask)])*numpy.nan
2297 data_2_nan = numpy.ones([angles_2_nan.shape[0],len(self.r_mask)])*numpy.nan
2298
2299 data_filled = numpy.concatenate((data_1_nan,data_weather,data_2_nan),axis=0)
2300 #val_mean = numpy.mean(data_weather[:,-1])
2301 #self.val_mean = val_mean
2302 print(data_filled)
2303 data_filled = self.replaceNAN(data_weather=data_filled,data_ele=angles_filled,val=numpy.nan)
2304
2305 print(data_filled)
2306 print(data_filled.shape)
2307 print(angles_filled.shape)
2308
2309 return data_filled,angles_filled
2310
2311 def plot(self):
2312 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
2313 data = self.data[-1]
2314 r = self.data.yrange
2315 delta_height = r[1]-r[0]
2316 r_mask = numpy.where(r>=0)[0]
2317 self.r_mask =r_mask
2318 ##print("delta_height",delta_height)
2319 #print("r_mask",r_mask,len(r_mask))
2320 r = numpy.arange(len(r_mask))*delta_height
2321 self.y = 2*r
2322 res = 1
2323 ###print("data['weather'].shape[0]",data['weather'].shape[0])
2324 ang_max = self.ang_max
2325 ang_min = self.ang_min
2326 var_ang =ang_max - ang_min
2327 step = (int(var_ang)/(res*data['weather'].shape[0]))
2328 ###print("step",step)
2329 #--------------------------------------------------------
2330 ##print('weather',data['weather'].shape)
2331 ##print('ele',data['ele'].shape)
2332
2333 ###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)
2334 ###self.res_azi = numpy.mean(data['azi'])
2335 ###print("self.res_ele",self.res_ele)
2336
2337 plt.clf()
2338 subplots = [121, 122]
2339 #if self.ini==0:
2340 #self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
2341 #print("SHAPE",self.data_ele_tmp.shape)
2342
2343 for i,ax in enumerate(self.axes):
2344 res_weather, self.res_ele = self.const_ploteo_vRF(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],res=res,ang_max=ang_max,ang_min=ang_min)
2345 self.res_azi = numpy.mean(data['azi'])
2346
2347 if ax.firsttime:
2348 #plt.clf()
2349 print("Frist Plot")
2350 print(data['weather'][i][:,r_mask].shape)
2351 print(data['ele'].shape)
2352 cgax, pm = wrl.vis.plot_rhi(res_weather,r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
2353 #cgax, pm = wrl.vis.plot_rhi(data['weather'][i][:,r_mask],r=r,th=data['ele'],ax=subplots[i], proj='cg',vmin=20, vmax=80)
2354 gh = cgax.get_grid_helper()
2355 locs = numpy.linspace(ang_min,ang_max,var_ang+1)
2356 gh.grid_finder.grid_locator1 = FixedLocator(locs)
2357 gh.grid_finder.tick_formatter1 = DictFormatter(dict([(i, r"${0:.0f}^\circ$".format(i)) for i in locs]))
2358
2359
2360 #fig=self.figures[0]
2361 else:
2362 #plt.clf()
2363 print("ELSE PLOT")
2364 cgax, pm = wrl.vis.plot_rhi(res_weather,r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
2365 #cgax, pm = wrl.vis.plot_rhi(data['weather'][i][:,r_mask],r=r,th=data['ele'],ax=subplots[i], proj='cg',vmin=20, vmax=80)
2366 gh = cgax.get_grid_helper()
2367 locs = numpy.linspace(ang_min,ang_max,var_ang+1)
2368 gh.grid_finder.grid_locator1 = FixedLocator(locs)
2369 gh.grid_finder.tick_formatter1 = DictFormatter(dict([(i, r"${0:.0f}^\circ$".format(i)) for i in locs]))
2370
2371 caax = cgax.parasites[0]
2372 paax = cgax.parasites[1]
2373 cbar = plt.gcf().colorbar(pm, pad=0.075)
2374 caax.set_xlabel('x_range [km]')
2375 caax.set_ylabel('y_range [km]')
2376 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')
2377 print("***************************self.ini****************************",self.ini)
2378 self.ini= self.ini+1
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