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

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

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