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