The requested changes are too big and content was truncated. Show full diff
@@ -1,900 +1,960 | |||
|
1 | 1 | import os |
|
2 | 2 | import datetime |
|
3 | 3 | import numpy |
|
4 | 4 | |
|
5 | 5 | from schainpy.model.graphics.jroplot_base import Plot, plt |
|
6 | 6 | from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot |
|
7 | 7 | from schainpy.utils import log |
|
8 | 8 | # libreria wradlib |
|
9 | 9 | import wradlib as wrl |
|
10 | 10 | |
|
11 | 11 | EARTH_RADIUS = 6.3710e3 |
|
12 | 12 | |
|
13 | 13 | |
|
14 | 14 | def ll2xy(lat1, lon1, lat2, lon2): |
|
15 | 15 | |
|
16 | 16 | p = 0.017453292519943295 |
|
17 | 17 | a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \ |
|
18 | 18 | numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2 |
|
19 | 19 | r = 12742 * numpy.arcsin(numpy.sqrt(a)) |
|
20 | 20 | theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p) |
|
21 | 21 | * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p)) |
|
22 | 22 | theta = -theta + numpy.pi/2 |
|
23 | 23 | return r*numpy.cos(theta), r*numpy.sin(theta) |
|
24 | 24 | |
|
25 | 25 | |
|
26 | 26 | def km2deg(km): |
|
27 | 27 | ''' |
|
28 | 28 | Convert distance in km to degrees |
|
29 | 29 | ''' |
|
30 | 30 | |
|
31 | 31 | return numpy.rad2deg(km/EARTH_RADIUS) |
|
32 | 32 | |
|
33 | 33 | |
|
34 | 34 | |
|
35 | 35 | class SpectralMomentsPlot(SpectraPlot): |
|
36 | 36 | ''' |
|
37 | 37 | Plot for Spectral Moments |
|
38 | 38 | ''' |
|
39 | 39 | CODE = 'spc_moments' |
|
40 | 40 | # colormap = 'jet' |
|
41 | 41 | # plot_type = 'pcolor' |
|
42 | 42 | |
|
43 | 43 | class DobleGaussianPlot(SpectraPlot): |
|
44 | 44 | ''' |
|
45 | 45 | Plot for Double Gaussian Plot |
|
46 | 46 | ''' |
|
47 | 47 | CODE = 'gaussian_fit' |
|
48 | 48 | # colormap = 'jet' |
|
49 | 49 | # plot_type = 'pcolor' |
|
50 | 50 | |
|
51 | 51 | class DoubleGaussianSpectraCutPlot(SpectraCutPlot): |
|
52 | 52 | ''' |
|
53 | 53 | Plot SpectraCut with Double Gaussian Fit |
|
54 | 54 | ''' |
|
55 | 55 | CODE = 'cut_gaussian_fit' |
|
56 | 56 | |
|
57 | 57 | class SnrPlot(RTIPlot): |
|
58 | 58 | ''' |
|
59 | 59 | Plot for SNR Data |
|
60 | 60 | ''' |
|
61 | 61 | |
|
62 | 62 | CODE = 'snr' |
|
63 | 63 | colormap = 'jet' |
|
64 | 64 | |
|
65 | 65 | def update(self, dataOut): |
|
66 | 66 | |
|
67 | 67 | data = { |
|
68 | 68 | 'snr': 10*numpy.log10(dataOut.data_snr) |
|
69 | 69 | } |
|
70 | 70 | |
|
71 | 71 | return data, {} |
|
72 | 72 | |
|
73 | 73 | class DopplerPlot(RTIPlot): |
|
74 | 74 | ''' |
|
75 | 75 | Plot for DOPPLER Data (1st moment) |
|
76 | 76 | ''' |
|
77 | 77 | |
|
78 | 78 | CODE = 'dop' |
|
79 | 79 | colormap = 'jet' |
|
80 | 80 | |
|
81 | 81 | def update(self, dataOut): |
|
82 | 82 | |
|
83 | 83 | data = { |
|
84 | 84 | 'dop': 10*numpy.log10(dataOut.data_dop) |
|
85 | 85 | } |
|
86 | 86 | |
|
87 | 87 | return data, {} |
|
88 | 88 | |
|
89 | 89 | class PowerPlot(RTIPlot): |
|
90 | 90 | ''' |
|
91 | 91 | Plot for Power Data (0 moment) |
|
92 | 92 | ''' |
|
93 | 93 | |
|
94 | 94 | CODE = 'pow' |
|
95 | 95 | colormap = 'jet' |
|
96 | 96 | |
|
97 | 97 | def update(self, dataOut): |
|
98 | 98 | data = { |
|
99 | 99 | 'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor) |
|
100 | 100 | } |
|
101 | 101 | return data, {} |
|
102 | 102 | |
|
103 | 103 | class SpectralWidthPlot(RTIPlot): |
|
104 | 104 | ''' |
|
105 | 105 | Plot for Spectral Width Data (2nd moment) |
|
106 | 106 | ''' |
|
107 | 107 | |
|
108 | 108 | CODE = 'width' |
|
109 | 109 | colormap = 'jet' |
|
110 | 110 | |
|
111 | 111 | def update(self, dataOut): |
|
112 | 112 | |
|
113 | 113 | data = { |
|
114 | 114 | 'width': dataOut.data_width |
|
115 | 115 | } |
|
116 | 116 | |
|
117 | 117 | return data, {} |
|
118 | 118 | |
|
119 | 119 | class SkyMapPlot(Plot): |
|
120 | 120 | ''' |
|
121 | 121 | Plot for meteors detection data |
|
122 | 122 | ''' |
|
123 | 123 | |
|
124 | 124 | CODE = 'param' |
|
125 | 125 | |
|
126 | 126 | def setup(self): |
|
127 | 127 | |
|
128 | 128 | self.ncols = 1 |
|
129 | 129 | self.nrows = 1 |
|
130 | 130 | self.width = 7.2 |
|
131 | 131 | self.height = 7.2 |
|
132 | 132 | self.nplots = 1 |
|
133 | 133 | self.xlabel = 'Zonal Zenith Angle (deg)' |
|
134 | 134 | self.ylabel = 'Meridional Zenith Angle (deg)' |
|
135 | 135 | self.polar = True |
|
136 | 136 | self.ymin = -180 |
|
137 | 137 | self.ymax = 180 |
|
138 | 138 | self.colorbar = False |
|
139 | 139 | |
|
140 | 140 | def plot(self): |
|
141 | 141 | |
|
142 | 142 | arrayParameters = numpy.concatenate(self.data['param']) |
|
143 | 143 | error = arrayParameters[:, -1] |
|
144 | 144 | indValid = numpy.where(error == 0)[0] |
|
145 | 145 | finalMeteor = arrayParameters[indValid, :] |
|
146 | 146 | finalAzimuth = finalMeteor[:, 3] |
|
147 | 147 | finalZenith = finalMeteor[:, 4] |
|
148 | 148 | |
|
149 | 149 | x = finalAzimuth * numpy.pi / 180 |
|
150 | 150 | y = finalZenith |
|
151 | 151 | |
|
152 | 152 | ax = self.axes[0] |
|
153 | 153 | |
|
154 | 154 | if ax.firsttime: |
|
155 | 155 | ax.plot = ax.plot(x, y, 'bo', markersize=5)[0] |
|
156 | 156 | else: |
|
157 | 157 | ax.plot.set_data(x, y) |
|
158 | 158 | |
|
159 | 159 | dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S') |
|
160 | 160 | dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S') |
|
161 | 161 | title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1, |
|
162 | 162 | dt2, |
|
163 | 163 | len(x)) |
|
164 | 164 | self.titles[0] = title |
|
165 | 165 | |
|
166 | 166 | |
|
167 | 167 | class GenericRTIPlot(Plot): |
|
168 | 168 | ''' |
|
169 | 169 | Plot for data_xxxx object |
|
170 | 170 | ''' |
|
171 | 171 | |
|
172 | 172 | CODE = 'param' |
|
173 | 173 | colormap = 'viridis' |
|
174 | 174 | plot_type = 'pcolorbuffer' |
|
175 | 175 | |
|
176 | 176 | def setup(self): |
|
177 | 177 | self.xaxis = 'time' |
|
178 | 178 | self.ncols = 1 |
|
179 | 179 | self.nrows = self.data.shape('param')[0] |
|
180 | 180 | self.nplots = self.nrows |
|
181 | 181 | self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95}) |
|
182 | 182 | |
|
183 | 183 | if not self.xlabel: |
|
184 | 184 | self.xlabel = 'Time' |
|
185 | 185 | |
|
186 | 186 | self.ylabel = 'Range [km]' |
|
187 | 187 | if not self.titles: |
|
188 | 188 | self.titles = ['Param {}'.format(x) for x in range(self.nrows)] |
|
189 | 189 | |
|
190 | 190 | def update(self, dataOut): |
|
191 | 191 | |
|
192 | 192 | data = { |
|
193 | 193 | 'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0) |
|
194 | 194 | } |
|
195 | 195 | |
|
196 | 196 | meta = {} |
|
197 | 197 | |
|
198 | 198 | return data, meta |
|
199 | 199 | |
|
200 | 200 | def plot(self): |
|
201 | 201 | # self.data.normalize_heights() |
|
202 | 202 | self.x = self.data.times |
|
203 | 203 | self.y = self.data.yrange |
|
204 | 204 | self.z = self.data['param'] |
|
205 | 205 | self.z = 10*numpy.log10(self.z) |
|
206 | 206 | self.z = numpy.ma.masked_invalid(self.z) |
|
207 | 207 | |
|
208 | 208 | if self.decimation is None: |
|
209 | 209 | x, y, z = self.fill_gaps(self.x, self.y, self.z) |
|
210 | 210 | else: |
|
211 | 211 | x, y, z = self.fill_gaps(*self.decimate()) |
|
212 | 212 | |
|
213 | 213 | for n, ax in enumerate(self.axes): |
|
214 | 214 | |
|
215 | 215 | self.zmax = self.zmax if self.zmax is not None else numpy.max( |
|
216 | 216 | self.z[n]) |
|
217 | 217 | self.zmin = self.zmin if self.zmin is not None else numpy.min( |
|
218 | 218 | self.z[n]) |
|
219 | 219 | |
|
220 | 220 | if ax.firsttime: |
|
221 | 221 | if self.zlimits is not None: |
|
222 | 222 | self.zmin, self.zmax = self.zlimits[n] |
|
223 | 223 | |
|
224 | 224 | ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n], |
|
225 | 225 | vmin=self.zmin, |
|
226 | 226 | vmax=self.zmax, |
|
227 | 227 | cmap=self.cmaps[n] |
|
228 | 228 | ) |
|
229 | 229 | else: |
|
230 | 230 | if self.zlimits is not None: |
|
231 | 231 | self.zmin, self.zmax = self.zlimits[n] |
|
232 | 232 | ax.collections.remove(ax.collections[0]) |
|
233 | 233 | ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n], |
|
234 | 234 | vmin=self.zmin, |
|
235 | 235 | vmax=self.zmax, |
|
236 | 236 | cmap=self.cmaps[n] |
|
237 | 237 | ) |
|
238 | 238 | |
|
239 | 239 | |
|
240 | 240 | class PolarMapPlot(Plot): |
|
241 | 241 | ''' |
|
242 | 242 | Plot for weather radar |
|
243 | 243 | ''' |
|
244 | 244 | |
|
245 | 245 | CODE = 'param' |
|
246 | 246 | colormap = 'seismic' |
|
247 | 247 | |
|
248 | 248 | def setup(self): |
|
249 | 249 | self.ncols = 1 |
|
250 | 250 | self.nrows = 1 |
|
251 | 251 | self.width = 9 |
|
252 | 252 | self.height = 8 |
|
253 | 253 | self.mode = self.data.meta['mode'] |
|
254 | 254 | if self.channels is not None: |
|
255 | 255 | self.nplots = len(self.channels) |
|
256 | 256 | self.nrows = len(self.channels) |
|
257 | 257 | else: |
|
258 | 258 | self.nplots = self.data.shape(self.CODE)[0] |
|
259 | 259 | self.nrows = self.nplots |
|
260 | 260 | self.channels = list(range(self.nplots)) |
|
261 | 261 | if self.mode == 'E': |
|
262 | 262 | self.xlabel = 'Longitude' |
|
263 | 263 | self.ylabel = 'Latitude' |
|
264 | 264 | else: |
|
265 | 265 | self.xlabel = 'Range (km)' |
|
266 | 266 | self.ylabel = 'Height (km)' |
|
267 | 267 | self.bgcolor = 'white' |
|
268 | 268 | self.cb_labels = self.data.meta['units'] |
|
269 | 269 | self.lat = self.data.meta['latitude'] |
|
270 | 270 | self.lon = self.data.meta['longitude'] |
|
271 | 271 | self.xmin, self.xmax = float( |
|
272 | 272 | km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon) |
|
273 | 273 | self.ymin, self.ymax = float( |
|
274 | 274 | km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat) |
|
275 | 275 | # self.polar = True |
|
276 | 276 | |
|
277 | 277 | def plot(self): |
|
278 | 278 | |
|
279 | 279 | for n, ax in enumerate(self.axes): |
|
280 | 280 | data = self.data['param'][self.channels[n]] |
|
281 | 281 | |
|
282 | 282 | zeniths = numpy.linspace( |
|
283 | 283 | 0, self.data.meta['max_range'], data.shape[1]) |
|
284 | 284 | if self.mode == 'E': |
|
285 | 285 | azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2 |
|
286 | 286 | r, theta = numpy.meshgrid(zeniths, azimuths) |
|
287 | 287 | x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin( |
|
288 | 288 | theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])) |
|
289 | 289 | x = km2deg(x) + self.lon |
|
290 | 290 | y = km2deg(y) + self.lat |
|
291 | 291 | else: |
|
292 | 292 | azimuths = numpy.radians(self.data.yrange) |
|
293 | 293 | r, theta = numpy.meshgrid(zeniths, azimuths) |
|
294 | 294 | x, y = r*numpy.cos(theta), r*numpy.sin(theta) |
|
295 | 295 | self.y = zeniths |
|
296 | 296 | |
|
297 | 297 | if ax.firsttime: |
|
298 | 298 | if self.zlimits is not None: |
|
299 | 299 | self.zmin, self.zmax = self.zlimits[n] |
|
300 | 300 | ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)), |
|
301 | 301 | x, y, numpy.ma.array(data, mask=numpy.isnan(data)), |
|
302 | 302 | vmin=self.zmin, |
|
303 | 303 | vmax=self.zmax, |
|
304 | 304 | cmap=self.cmaps[n]) |
|
305 | 305 | else: |
|
306 | 306 | if self.zlimits is not None: |
|
307 | 307 | self.zmin, self.zmax = self.zlimits[n] |
|
308 | 308 | ax.collections.remove(ax.collections[0]) |
|
309 | 309 | ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)), |
|
310 | 310 | x, y, numpy.ma.array(data, mask=numpy.isnan(data)), |
|
311 | 311 | vmin=self.zmin, |
|
312 | 312 | vmax=self.zmax, |
|
313 | 313 | cmap=self.cmaps[n]) |
|
314 | 314 | |
|
315 | 315 | if self.mode == 'A': |
|
316 | 316 | continue |
|
317 | 317 | |
|
318 | 318 | # plot district names |
|
319 | 319 | f = open('/data/workspace/schain_scripts/distrito.csv') |
|
320 | 320 | for line in f: |
|
321 | 321 | label, lon, lat = [s.strip() for s in line.split(',') if s] |
|
322 | 322 | lat = float(lat) |
|
323 | 323 | lon = float(lon) |
|
324 | 324 | # ax.plot(lon, lat, '.b', ms=2) |
|
325 | 325 | ax.text(lon, lat, label.decode('utf8'), ha='center', |
|
326 | 326 | va='bottom', size='8', color='black') |
|
327 | 327 | |
|
328 | 328 | # plot limites |
|
329 | 329 | limites = [] |
|
330 | 330 | tmp = [] |
|
331 | 331 | for line in open('/data/workspace/schain_scripts/lima.csv'): |
|
332 | 332 | if '#' in line: |
|
333 | 333 | if tmp: |
|
334 | 334 | limites.append(tmp) |
|
335 | 335 | tmp = [] |
|
336 | 336 | continue |
|
337 | 337 | values = line.strip().split(',') |
|
338 | 338 | tmp.append((float(values[0]), float(values[1]))) |
|
339 | 339 | for points in limites: |
|
340 | 340 | ax.add_patch( |
|
341 | 341 | Polygon(points, ec='k', fc='none', ls='--', lw=0.5)) |
|
342 | 342 | |
|
343 | 343 | # plot Cuencas |
|
344 | 344 | for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'): |
|
345 | 345 | f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca)) |
|
346 | 346 | values = [line.strip().split(',') for line in f] |
|
347 | 347 | points = [(float(s[0]), float(s[1])) for s in values] |
|
348 | 348 | ax.add_patch(Polygon(points, ec='b', fc='none')) |
|
349 | 349 | |
|
350 | 350 | # plot grid |
|
351 | 351 | for r in (15, 30, 45, 60): |
|
352 | 352 | ax.add_artist(plt.Circle((self.lon, self.lat), |
|
353 | 353 | km2deg(r), color='0.6', fill=False, lw=0.2)) |
|
354 | 354 | ax.text( |
|
355 | 355 | self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180), |
|
356 | 356 | self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180), |
|
357 | 357 | '{}km'.format(r), |
|
358 | 358 | ha='center', va='bottom', size='8', color='0.6', weight='heavy') |
|
359 | 359 | |
|
360 | 360 | if self.mode == 'E': |
|
361 | 361 | title = 'El={}$^\circ$'.format(self.data.meta['elevation']) |
|
362 | 362 | label = 'E{:02d}'.format(int(self.data.meta['elevation'])) |
|
363 | 363 | else: |
|
364 | 364 | title = 'Az={}$^\circ$'.format(self.data.meta['azimuth']) |
|
365 | 365 | label = 'A{:02d}'.format(int(self.data.meta['azimuth'])) |
|
366 | 366 | |
|
367 | 367 | self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels] |
|
368 | 368 | self.titles = ['{} {}'.format( |
|
369 | 369 | self.data.parameters[x], title) for x in self.channels] |
|
370 | 370 | |
|
371 | 371 | class WeatherPlot(Plot): |
|
372 | 372 | CODE = 'weather' |
|
373 | 373 | plot_name = 'weather' |
|
374 | 374 | plot_type = 'ppistyle' |
|
375 | 375 | buffering = False |
|
376 | 376 | |
|
377 | 377 | def setup(self): |
|
378 | 378 | self.ncols = 1 |
|
379 | 379 | self.nrows = 1 |
|
380 | 380 | self.nplots= 1 |
|
381 | 381 | self.ylabel= 'Range [Km]' |
|
382 | 382 | self.titles= ['Weather'] |
|
383 | 383 | self.colorbar=False |
|
384 | 384 | self.width =8 |
|
385 | 385 | self.height =8 |
|
386 | 386 | self.ini =0 |
|
387 | 387 | self.len_azi =0 |
|
388 | 388 | self.buffer_ini = None |
|
389 | 389 | self.buffer_azi = None |
|
390 | 390 | self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08}) |
|
391 | 391 | self.flag =0 |
|
392 | 392 | self.indicador= 0 |
|
393 | 393 | self.last_data_azi = None |
|
394 | 394 | self.val_mean = None |
|
395 | 395 | |
|
396 | 396 | def update(self, dataOut): |
|
397 | 397 | |
|
398 | 398 | data = {} |
|
399 | 399 | meta = {} |
|
400 | 400 | if hasattr(dataOut, 'dataPP_POWER'): |
|
401 | 401 | factor = 1 |
|
402 | 402 | if hasattr(dataOut, 'nFFTPoints'): |
|
403 | 403 | factor = dataOut.normFactor |
|
404 | 404 | print("DIME EL SHAPE PORFAVOR",dataOut.data_360.shape) |
|
405 | 405 | data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor)) |
|
406 | 406 | data['azi'] = dataOut.data_azi |
|
407 | 407 | data['ele'] = dataOut.data_ele |
|
408 | 408 | return data, meta |
|
409 | 409 | |
|
410 | 410 | def get2List(self,angulos): |
|
411 | 411 | list1=[] |
|
412 | 412 | list2=[] |
|
413 | 413 | for i in reversed(range(len(angulos))): |
|
414 | 414 | diff_ = angulos[i]-angulos[i-1] |
|
415 | 415 | if diff_ >1.5: |
|
416 | 416 | list1.append(i-1) |
|
417 | 417 | list2.append(diff_) |
|
418 | 418 | return list(reversed(list1)),list(reversed(list2)) |
|
419 | 419 | |
|
420 | 420 | def fixData360(self,list_,ang_): |
|
421 | 421 | if list_[0]==-1: |
|
422 | 422 | vec = numpy.where(ang_<ang_[0]) |
|
423 | 423 | ang_[vec] = ang_[vec]+360 |
|
424 | 424 | return ang_ |
|
425 | 425 | return ang_ |
|
426 | 426 | |
|
427 | 427 | def fixData360HL(self,angulos): |
|
428 | 428 | vec = numpy.where(angulos>=360) |
|
429 | 429 | angulos[vec]=angulos[vec]-360 |
|
430 | 430 | return angulos |
|
431 | 431 | |
|
432 | 432 | def search_pos(self,pos,list_): |
|
433 | 433 | for i in range(len(list_)): |
|
434 | 434 | if pos == list_[i]: |
|
435 | 435 | return True,i |
|
436 | 436 | i=None |
|
437 | 437 | return False,i |
|
438 | 438 | |
|
439 | 439 | def fixDataComp(self,ang_,list1_,list2_): |
|
440 | 440 | size = len(ang_) |
|
441 | 441 | size2 = 0 |
|
442 | 442 | for i in range(len(list2_)): |
|
443 | 443 | size2=size2+round(list2_[i])-1 |
|
444 | 444 | new_size= size+size2 |
|
445 | 445 | ang_new = numpy.zeros(new_size) |
|
446 | 446 | ang_new2 = numpy.zeros(new_size) |
|
447 | 447 | |
|
448 | 448 | tmp = 0 |
|
449 | 449 | c = 0 |
|
450 | 450 | for i in range(len(ang_)): |
|
451 | 451 | ang_new[tmp +c] = ang_[i] |
|
452 | 452 | ang_new2[tmp+c] = ang_[i] |
|
453 | 453 | condition , value = self.search_pos(i,list1_) |
|
454 | 454 | if condition: |
|
455 | 455 | pos = tmp + c + 1 |
|
456 | 456 | for k in range(round(list2_[value])-1): |
|
457 | 457 | ang_new[pos+k] = ang_new[pos+k-1]+1 |
|
458 | 458 | ang_new2[pos+k] = numpy.nan |
|
459 | 459 | tmp = pos +k |
|
460 | 460 | c = 0 |
|
461 | 461 | c=c+1 |
|
462 | 462 | return ang_new,ang_new2 |
|
463 | 463 | |
|
464 | 464 | def globalCheckPED(self,angulos): |
|
465 | 465 | l1,l2 = self.get2List(angulos) |
|
466 | 466 | if len(l1)>0: |
|
467 | 467 | angulos2 = self.fixData360(list_=l1,ang_=angulos) |
|
468 | 468 | l1,l2 = self.get2List(angulos2) |
|
469 | 469 | |
|
470 | 470 | ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2) |
|
471 | 471 | ang1_ = self.fixData360HL(ang1_) |
|
472 | 472 | ang2_ = self.fixData360HL(ang2_) |
|
473 | 473 | else: |
|
474 | 474 | ang1_= angulos |
|
475 | 475 | ang2_= angulos |
|
476 | 476 | return ang1_,ang2_ |
|
477 | 477 | |
|
478 | 478 | def analizeDATA(self,data_azi): |
|
479 | 479 | list1 = [] |
|
480 | 480 | list2 = [] |
|
481 | 481 | dat = data_azi |
|
482 | 482 | for i in reversed(range(1,len(dat))): |
|
483 | 483 | if dat[i]>dat[i-1]: |
|
484 | 484 | diff = int(dat[i])-int(dat[i-1]) |
|
485 | 485 | else: |
|
486 | 486 | diff = 360+int(dat[i])-int(dat[i-1]) |
|
487 | 487 | if diff > 1: |
|
488 | 488 | list1.append(i-1) |
|
489 | 489 | list2.append(diff-1) |
|
490 | 490 | return list1,list2 |
|
491 | 491 | |
|
492 | 492 | def fixDATANEW(self,data_azi,data_weather): |
|
493 | 493 | list1,list2 = self.analizeDATA(data_azi) |
|
494 | 494 | if len(list1)== 0: |
|
495 | 495 | return data_azi,data_weather |
|
496 | 496 | else: |
|
497 | 497 | resize = 0 |
|
498 | 498 | for i in range(len(list2)): |
|
499 | 499 | resize= resize + list2[i] |
|
500 | 500 | new_data_azi = numpy.resize(data_azi,resize) |
|
501 | 501 | new_data_weather= numpy.resize(date_weather,resize) |
|
502 | 502 | |
|
503 | 503 | for i in range(len(list2)): |
|
504 | 504 | j=0 |
|
505 | 505 | position=list1[i]+1 |
|
506 | 506 | for j in range(list2[i]): |
|
507 | 507 | new_data_azi[position+j]=new_data_azi[position+j-1]+1 |
|
508 | 508 | return new_data_azi |
|
509 | 509 | |
|
510 | 510 | def fixDATA(self,data_azi): |
|
511 | 511 | data=data_azi |
|
512 | 512 | for i in range(len(data)): |
|
513 | 513 | if numpy.isnan(data[i]): |
|
514 | 514 | data[i]=data[i-1]+1 |
|
515 | 515 | return data |
|
516 | 516 | |
|
517 | 517 | def replaceNAN(self,data_weather,data_azi,val): |
|
518 | 518 | data= data_azi |
|
519 | 519 | data_T= data_weather |
|
520 | 520 | if data.shape[0]> data_T.shape[0]: |
|
521 | 521 | data_N = numpy.ones( [data.shape[0],data_T.shape[1]]) |
|
522 | 522 | c = 0 |
|
523 | 523 | for i in range(len(data)): |
|
524 | 524 | if numpy.isnan(data[i]): |
|
525 | 525 | data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan |
|
526 | 526 | else: |
|
527 | 527 | data_N[i,:]=data_T[c,:] |
|
528 | 528 | sc=c+1 |
|
529 | 529 | else: |
|
530 | 530 | for i in range(len(data)): |
|
531 | 531 | if numpy.isnan(data[i]): |
|
532 | 532 | data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan |
|
533 | 533 | return data_T |
|
534 | 534 | |
|
535 | 535 | def const_ploteo(self,data_weather,data_azi,step,res): |
|
536 | 536 | if self.ini==0: |
|
537 | 537 | #------- |
|
538 | 538 | n = (360/res)-len(data_azi) |
|
539 | 539 | #--------------------- new ------------------------- |
|
540 | 540 | data_azi_new ,data_azi_old= self.globalCheckPED(data_azi) |
|
541 | 541 | #------------------------ |
|
542 | 542 | start = data_azi_new[-1] + res |
|
543 | 543 | end = data_azi_new[0] - res |
|
544 | 544 | #------ new |
|
545 | 545 | self.last_data_azi = end |
|
546 | 546 | if start>end: |
|
547 | 547 | end = end + 360 |
|
548 | 548 | azi_vacia = numpy.linspace(start,end,int(n)) |
|
549 | 549 | azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia) |
|
550 | 550 | data_azi = numpy.hstack((data_azi_new,azi_vacia)) |
|
551 | 551 | # RADAR |
|
552 | 552 | val_mean = numpy.mean(data_weather[:,-1]) |
|
553 | 553 | self.val_mean = val_mean |
|
554 | 554 | data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean |
|
555 | 555 | data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean) |
|
556 | 556 | data_weather = numpy.vstack((data_weather,data_weather_cmp)) |
|
557 | 557 | else: |
|
558 | 558 | # azimuth |
|
559 | 559 | flag=0 |
|
560 | 560 | start_azi = self.res_azi[0] |
|
561 | 561 | #-----------new------------ |
|
562 | 562 | data_azi ,data_azi_old= self.globalCheckPED(data_azi) |
|
563 | 563 | data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean) |
|
564 | 564 | #-------------------------- |
|
565 | 565 | start = data_azi[0] |
|
566 | 566 | end = data_azi[-1] |
|
567 | 567 | self.last_data_azi= end |
|
568 | 568 | if start< start_azi: |
|
569 | 569 | start = start +360 |
|
570 | 570 | if end <start_azi: |
|
571 | 571 | end = end +360 |
|
572 | 572 | |
|
573 | 573 | pos_ini = int((start-start_azi)/res) |
|
574 | 574 | len_azi = len(data_azi) |
|
575 | 575 | if (360-pos_ini)<len_azi: |
|
576 | 576 | if pos_ini+1==360: |
|
577 | 577 | pos_ini=0 |
|
578 | 578 | else: |
|
579 | 579 | flag=1 |
|
580 | 580 | dif= 360-pos_ini |
|
581 | 581 | comp= len_azi-dif |
|
582 | 582 | #----------------- |
|
583 | 583 | if flag==0: |
|
584 | 584 | # AZIMUTH |
|
585 | 585 | self.res_azi[pos_ini:pos_ini+len_azi] = data_azi |
|
586 | 586 | # RADAR |
|
587 | 587 | self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather |
|
588 | 588 | else: |
|
589 | 589 | # AZIMUTH |
|
590 | 590 | self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif] |
|
591 | 591 | self.res_azi[0:comp] = data_azi[dif:] |
|
592 | 592 | # RADAR |
|
593 | 593 | self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:] |
|
594 | 594 | self.res_weather[0:comp,:] = data_weather[dif:,:] |
|
595 | 595 | flag=0 |
|
596 | 596 | data_azi = self.res_azi |
|
597 | 597 | data_weather = self.res_weather |
|
598 | 598 | |
|
599 | 599 | return data_weather,data_azi |
|
600 | 600 | |
|
601 | 601 | def plot(self): |
|
602 | 602 | thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S') |
|
603 | 603 | data = self.data[-1] |
|
604 | 604 | r = self.data.yrange |
|
605 | 605 | delta_height = r[1]-r[0] |
|
606 | 606 | r_mask = numpy.where(r>=0)[0] |
|
607 | 607 | r = numpy.arange(len(r_mask))*delta_height |
|
608 | 608 | self.y = 2*r |
|
609 | 609 | # RADAR |
|
610 | 610 | #data_weather = data['weather'] |
|
611 | 611 | # PEDESTAL |
|
612 | 612 | #data_azi = data['azi'] |
|
613 | 613 | res = 1 |
|
614 | 614 | # STEP |
|
615 | 615 | step = (360/(res*data['weather'].shape[0])) |
|
616 | 616 | |
|
617 | 617 | self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res) |
|
618 | 618 | self.res_ele = numpy.mean(data['ele']) |
|
619 | 619 | ################# PLOTEO ################### |
|
620 | 620 | print("self.axes",self.axes) |
|
621 | 621 | for i,ax in enumerate(self.axes): |
|
622 | 622 | print("INDICE: ",i) |
|
623 | 623 | if ax.firsttime: |
|
624 | 624 | plt.clf() |
|
625 | 625 | cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=20, vmax=80) |
|
626 | 626 | else: |
|
627 | 627 | plt.clf() |
|
628 | 628 | cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=20, vmax=80) |
|
629 | 629 | caax = cgax.parasites[0] |
|
630 | 630 | paax = cgax.parasites[1] |
|
631 | 631 | cbar = plt.gcf().colorbar(pm, pad=0.075) |
|
632 | 632 | caax.set_xlabel('x_range [km]') |
|
633 | 633 | caax.set_ylabel('y_range [km]') |
|
634 | 634 | plt.text(1.0, 1.05, 'Azimuth '+str(thisDatetime)+" Step "+str(self.ini)+ " Elev: "+str(round(self.res_ele,2)), transform=caax.transAxes, va='bottom',ha='right') |
|
635 | 635 | |
|
636 | 636 | self.ini= self.ini+1 |
|
637 | 637 | |
|
638 | 638 | |
|
639 | 639 | class WeatherRHIPlot(Plot): |
|
640 | 640 | CODE = 'weather' |
|
641 | 641 | plot_name = 'weather' |
|
642 | 642 | plot_type = 'rhistyle' |
|
643 | 643 | buffering = False |
|
644 | 644 | |
|
645 | 645 | def setup(self): |
|
646 | 646 | self.ncols = 1 |
|
647 | 647 | self.nrows = 1 |
|
648 | 648 | self.nplots= 1 |
|
649 | 649 | self.ylabel= 'Range [Km]' |
|
650 | 650 | self.titles= ['Weather'] |
|
651 | 651 | self.colorbar=False |
|
652 | 652 | self.width =8 |
|
653 | 653 | self.height =8 |
|
654 | 654 | self.ini =0 |
|
655 | 655 | self.len_azi =0 |
|
656 | 656 | self.buffer_ini = None |
|
657 | 657 | self.buffer_ele = None |
|
658 | 658 | self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08}) |
|
659 | 659 | self.flag =0 |
|
660 | 660 | self.indicador= 0 |
|
661 | 661 | self.last_data_ele = None |
|
662 | 662 | self.val_mean = None |
|
663 | 663 | |
|
664 | 664 | def update(self, dataOut): |
|
665 | 665 | |
|
666 | 666 | data = {} |
|
667 | 667 | meta = {} |
|
668 | 668 | if hasattr(dataOut, 'dataPP_POWER'): |
|
669 | 669 | factor = 1 |
|
670 | 670 | if hasattr(dataOut, 'nFFTPoints'): |
|
671 | 671 | factor = dataOut.normFactor |
|
672 | 672 | data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor)) |
|
673 | 673 | data['azi'] = dataOut.data_azi |
|
674 | 674 | data['ele'] = dataOut.data_ele |
|
675 | 675 | return data, meta |
|
676 | 676 | |
|
677 | 677 | def get2List(self,angulos): |
|
678 | 678 | list1=[] |
|
679 | 679 | list2=[] |
|
680 | 680 | for i in reversed(range(len(angulos))): |
|
681 | if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante | |
|
681 | 682 | diff_ = angulos[i]-angulos[i-1] |
|
682 | if diff_ >1.5: | |
|
683 | if abs(diff_) >1.5: | |
|
683 | 684 | list1.append(i-1) |
|
684 | 685 | list2.append(diff_) |
|
685 | 686 | return list(reversed(list1)),list(reversed(list2)) |
|
686 | 687 | |
|
687 |
def fixData |
|
|
688 | def fixData90(self,list_,ang_): | |
|
688 | 689 | if list_[0]==-1: |
|
689 | 690 | vec = numpy.where(ang_<ang_[0]) |
|
690 |
ang_[vec] = ang_[vec]+ |
|
|
691 | ang_[vec] = ang_[vec]+90 | |
|
691 | 692 | return ang_ |
|
692 | 693 | return ang_ |
|
693 | 694 | |
|
694 |
def fixData |
|
|
695 |
vec = numpy.where(angulos>= |
|
|
696 |
angulos[vec]=angulos[vec]- |
|
|
695 | def fixData90HL(self,angulos): | |
|
696 | vec = numpy.where(angulos>=90) | |
|
697 | angulos[vec]=angulos[vec]-90 | |
|
697 | 698 | return angulos |
|
698 | 699 | |
|
699 | 700 | |
|
700 | 701 | def search_pos(self,pos,list_): |
|
701 | 702 | for i in range(len(list_)): |
|
702 | 703 | if pos == list_[i]: |
|
703 | 704 | return True,i |
|
704 | 705 | i=None |
|
705 | 706 | return False,i |
|
706 | 707 | |
|
707 | def fixDataComp(self,ang_,list1_,list2_): | |
|
708 | def fixDataComp(self,ang_,list1_,list2_,tipo_case): | |
|
708 | 709 | size = len(ang_) |
|
709 | 710 | size2 = 0 |
|
710 | 711 | for i in range(len(list2_)): |
|
711 | size2=size2+round(list2_[i])-1 | |
|
712 | size2=size2+round(abs(list2_[i]))-1 | |
|
712 | 713 | new_size= size+size2 |
|
713 | 714 | ang_new = numpy.zeros(new_size) |
|
714 | 715 | ang_new2 = numpy.zeros(new_size) |
|
715 | 716 | |
|
716 | 717 | tmp = 0 |
|
717 | 718 | c = 0 |
|
718 | 719 | for i in range(len(ang_)): |
|
719 | 720 | ang_new[tmp +c] = ang_[i] |
|
720 | 721 | ang_new2[tmp+c] = ang_[i] |
|
721 | 722 | condition , value = self.search_pos(i,list1_) |
|
722 | 723 | if condition: |
|
723 | 724 | pos = tmp + c + 1 |
|
724 | for k in range(round(list2_[value])-1): | |
|
725 | for k in range(round(abs(list2_[value]))-1): | |
|
726 | if tipo_case==0 or tipo_case==3:#subida | |
|
725 | 727 | ang_new[pos+k] = ang_new[pos+k-1]+1 |
|
726 | 728 | ang_new2[pos+k] = numpy.nan |
|
729 | elif tipo_case==1 or tipo_case==2:#bajada | |
|
730 | ang_new[pos+k] = ang_new[pos+k-1]-1 | |
|
731 | ang_new2[pos+k] = numpy.nan | |
|
732 | ||
|
727 | 733 | tmp = pos +k |
|
728 | 734 | c = 0 |
|
729 | 735 | c=c+1 |
|
730 | 736 | return ang_new,ang_new2 |
|
731 | 737 | |
|
732 | def globalCheckPED(self,angulos): | |
|
738 | def globalCheckPED(self,angulos,tipo_case): | |
|
733 | 739 | l1,l2 = self.get2List(angulos) |
|
740 | print("l1",l1) | |
|
741 | print("l2",l2) | |
|
734 | 742 | if len(l1)>0: |
|
735 |
angulos2 = self.fixData |
|
|
736 | l1,l2 = self.get2List(angulos2) | |
|
737 | ||
|
738 |
ang1 |
|
|
739 |
|
|
|
740 | ang2_ = self.fixData180HL(ang2_) | |
|
743 | #angulos2 = self.fixData90(list_=l1,ang_=angulos) | |
|
744 | #l1,l2 = self.get2List(angulos2) | |
|
745 | ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case) | |
|
746 | #ang1_ = self.fixData90HL(ang1_) | |
|
747 | #ang2_ = self.fixData90HL(ang2_) | |
|
741 | 748 | else: |
|
742 | 749 | ang1_= angulos |
|
743 | 750 | ang2_= angulos |
|
744 | 751 | return ang1_,ang2_ |
|
745 | 752 | |
|
746 | 753 | |
|
747 | 754 | def replaceNAN(self,data_weather,data_ele,val): |
|
748 | 755 | data= data_ele |
|
749 | 756 | data_T= data_weather |
|
750 | 757 | if data.shape[0]> data_T.shape[0]: |
|
751 | 758 | data_N = numpy.ones( [data.shape[0],data_T.shape[1]]) |
|
752 | 759 | c = 0 |
|
753 | 760 | for i in range(len(data)): |
|
754 | 761 | if numpy.isnan(data[i]): |
|
755 | 762 | data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan |
|
756 | 763 | else: |
|
757 | 764 | data_N[i,:]=data_T[c,:] |
|
758 | 765 | sc=c+1 |
|
759 | 766 | else: |
|
760 | 767 | for i in range(len(data)): |
|
761 | 768 | if numpy.isnan(data[i]): |
|
762 | 769 | data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan |
|
763 | 770 | return data_T |
|
764 | 771 | |
|
765 | def const_ploteo(self,data_weather,data_ele,step,res): | |
|
772 | def check_case(self,data_ele,ang_max,ang_min): | |
|
773 | start = data_ele[0] | |
|
774 | end = data_ele[-1] | |
|
775 | number = (end-start) | |
|
776 | len_ang=len(data_ele) | |
|
777 | ||
|
778 | if start<end and round(abs(number)+1)>=len_ang:#caso subida | |
|
779 | return 0 | |
|
780 | elif start>end and round(abs(number)+1)>=len_ang:#caso bajada | |
|
781 | return 1 | |
|
782 | elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX | |
|
783 | return 2 | |
|
784 | elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1]:# caso SUBIDA CAMBIO ANG MIN | |
|
785 | return 3 | |
|
786 | ||
|
787 | ||
|
788 | def const_ploteo(self,data_weather,data_ele,step,res,ang_max,ang_min): | |
|
789 | ang_max= ang_max | |
|
790 | ang_min= ang_min | |
|
766 | 791 | if self.ini==0: |
|
767 | #------- | |
|
768 | n = (180/res)-len(data_ele) | |
|
792 | print("**********************************************") | |
|
793 | print("**********************************************") | |
|
794 | print("***************ini**************") | |
|
795 | print("**********************************************") | |
|
796 | print("**********************************************") | |
|
797 | print("data_ele",data_ele) | |
|
798 | #---------------------------------------------------------- | |
|
799 | tipo_case = self.check_case(data_ele,ang_max,ang_min) | |
|
800 | print("TIPO DE DATA",tipo_case) | |
|
769 | 801 | #--------------------- new ------------------------- |
|
770 | data_ele_new ,data_ele_old= self.globalCheckPED(data_ele) | |
|
771 | #------------------------ | |
|
772 | start = data_ele_new[-1] + res | |
|
773 | end = data_ele_new[0] - res | |
|
802 | data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case) | |
|
803 | print("data_ele_new",data_ele_new) | |
|
804 | print("data_ele_old",data_ele_old) | |
|
805 | #-------------------------CAMBIOS RHI--------------------------------- | |
|
806 | start= ang_min | |
|
807 | end = ang_min | |
|
808 | n= (ang_max-ang_min)/res | |
|
774 | 809 | #------ new |
|
775 |
self. |
|
|
776 | if start>end: | |
|
777 | end = end + 180 | |
|
810 | self.start_data_ele = data_ele_new[0] | |
|
811 | self.end_data_ele = data_ele_new[-1] | |
|
812 | if tipo_case==0 or tipo_case==3: | |
|
813 | n1= round(self.start_data_ele)- start | |
|
814 | n2= end - round(self.end_data_ele) | |
|
815 | if n1>0: | |
|
816 | ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1) | |
|
817 | ele1_nan= numpy.ones(n1)*numpy.nan | |
|
818 | data_ele = numpy.hstack((ele1,data_ele_new)) | |
|
819 | data_ele_old = numpy.hstack((ele1_nan,data_ele_old)) | |
|
820 | if n2>0: | |
|
821 | ele2= numpy.linspace(self.end_data_ele+1,end,n2) | |
|
822 | ele2_nan= numpy.ones(n2)*numpy.nan | |
|
823 | data_ele = numpy.hstack((data_ele,ele2)) | |
|
824 | data_ele_old = numpy.hstack((data_ele_old,ele2_nan)) | |
|
825 | # RADAR | |
|
826 | val_mean = numpy.mean(data_weather[:,-1]) | |
|
827 | self.val_mean = val_mean | |
|
828 | data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean) | |
|
829 | ''' | |
|
778 | 830 | ele_vacia = numpy.linspace(start,end,int(n)) |
|
779 | ele_vacia = numpy.where(ele_vacia>180,ele_vacia-180,ele_vacia) | |
|
831 | ||
|
832 | ||
|
833 | ele_vacia = numpy.where(ele_vacia>ang_max,ele_vacia-ang_max,ele_vacia) | |
|
780 | 834 | data_ele = numpy.hstack((data_ele_new,ele_vacia)) |
|
781 | 835 | # RADAR |
|
782 | 836 | val_mean = numpy.mean(data_weather[:,-1]) |
|
783 | 837 | self.val_mean = val_mean |
|
784 |
data_weather_cmp = numpy.ones([( |
|
|
838 | data_weather_cmp = numpy.ones([(ang_max-data_weather.shape[0]),data_weather.shape[1]])*val_mean | |
|
785 | 839 | data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean) |
|
786 | 840 | data_weather = numpy.vstack((data_weather,data_weather_cmp)) |
|
841 | ''' | |
|
787 | 842 | else: |
|
788 | # azimuth | |
|
843 | print("**********************************************") | |
|
844 | print("**********************************************") | |
|
845 | print("****************VARIABLE**********************") | |
|
846 | print("**********************************************") | |
|
847 | print("**********************************************") | |
|
848 | #-------------------------CAMBIOS RHI--------------------------------- | |
|
849 | #--------------------------------------------------------------------- | |
|
850 | print("INPUT data_ele",data_ele) | |
|
789 | 851 | flag=0 |
|
790 | 852 | start_ele = self.res_ele[0] |
|
853 | tipo_case = self.check_case(data_ele,ang_max,ang_min) | |
|
854 | print("TIPO DE DATA",tipo_case) | |
|
791 | 855 | #-----------new------------ |
|
792 | data_ele ,data_ele_old= self.globalCheckPED(data_ele) | |
|
856 | data_ele ,data_ele_old= self.globalCheckPED(data_ele,tipo_case) | |
|
857 | print("data_ele_new",data_ele) | |
|
858 | print("data_ele_old",data_ele_old) | |
|
793 | 859 | data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean) |
|
860 | ''' | |
|
794 | 861 | #-------------------------- |
|
795 | 862 | start = data_ele[0] |
|
796 | 863 | end = data_ele[-1] |
|
797 | 864 | self.last_data_ele= end |
|
798 | 865 | if start< start_ele: |
|
799 |
start = start + |
|
|
866 | start = start +ang_max | |
|
800 | 867 | if end <start_ele: |
|
801 |
end = end + |
|
|
868 | end = end +ang_max | |
|
802 | 869 |
|
|
803 | 870 | pos_ini = int((start-start_ele)/res) |
|
804 | 871 | len_ele = len(data_ele) |
|
805 |
if ( |
|
|
806 |
if pos_ini+1== |
|
|
872 | if (ang_max-pos_ini)<len_ele: | |
|
873 | if pos_ini+1==ang_max: | |
|
807 | 874 | pos_ini=0 |
|
808 | 875 | else: |
|
809 | 876 | flag=1 |
|
810 |
dif= |
|
|
877 | dif= ang_max-pos_ini | |
|
811 | 878 | comp= len_ele-dif |
|
812 | 879 | #----------------- |
|
813 | 880 | if flag==0: |
|
814 | 881 | # elevacion |
|
815 | 882 | self.res_ele[pos_ini:pos_ini+len_ele] = data_ele |
|
816 | 883 | # RADAR |
|
817 | 884 | self.res_weather[pos_ini:pos_ini+len_ele,:] = data_weather |
|
818 | 885 | else: |
|
819 | 886 | # elevacion |
|
820 | 887 | self.res_ele[pos_ini:pos_ini+dif] = data_ele[0:dif] |
|
821 | 888 | self.res_ele[0:comp] = data_ele[dif:] |
|
822 | 889 | # RADAR |
|
823 | 890 | self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:] |
|
824 | 891 | self.res_weather[0:comp,:] = data_weather[dif:,:] |
|
825 | 892 | flag=0 |
|
826 | 893 | data_ele = self.res_ele |
|
827 | 894 | data_weather = self.res_weather |
|
895 | ''' | |
|
896 | print("OUPUT data_ele",data_ele) | |
|
828 | 897 | |
|
829 | 898 | return data_weather,data_ele |
|
830 | 899 | |
|
831 | 900 | |
|
832 | 901 | def plot(self): |
|
833 | 902 | thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S') |
|
834 | 903 | data = self.data[-1] |
|
835 | 904 | r = self.data.yrange |
|
836 | 905 | delta_height = r[1]-r[0] |
|
837 | 906 | r_mask = numpy.where(r>=0)[0] |
|
838 | 907 | r = numpy.arange(len(r_mask))*delta_height |
|
839 | 908 | self.y = 2*r |
|
909 | res = 1 | |
|
910 | print("data['weather'].shape[0]",data['weather'].shape[0]) | |
|
911 | ang_max = 80 | |
|
912 | ang_min = 0 | |
|
913 | var_ang =ang_max - ang_min | |
|
914 | step = (int(var_ang)/(res*data['weather'].shape[0])) | |
|
915 | print("step",step) | |
|
840 | 916 | ''' |
|
841 | 917 | #------------------------------------------------------------- |
|
842 | 918 | # RADAR |
|
843 | 919 | #data_weather = data['weather'] |
|
844 | 920 | # PEDESTAL |
|
845 | 921 | #data_azi = data['azi'] |
|
846 | 922 | res = 1 |
|
847 | 923 | # STEP |
|
848 | 924 | step = (180/(res*data['weather'].shape[0])) |
|
849 | ||
|
850 | ||
|
851 | 925 | self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res) |
|
852 | 926 | self.res_azi = numpy.mean(data['azi']) |
|
853 | 927 | print("self.res_ele------------------------------:",self.res_ele) |
|
854 | ################# PLOTEO ################### | |
|
855 | ||
|
856 | for i,ax in enumerate(self.axes): | |
|
857 | if ax.firsttime: | |
|
858 | plt.clf() | |
|
859 | cgax, pm = wrl.vis.plot_rhi(self.res_weather,r=r,th=self.res_ele,fig=self.figures[0], proj='cg', vmin=8, vmax=35) | |
|
860 | else: | |
|
861 | plt.clf() | |
|
862 | cgax, pm = wrl.vis.plot_rhi(self.res_weather,r=r,th=self.res_ele,fig=self.figures[0], proj='cg', vmin=8, vmax=35) | |
|
863 | caax = cgax.parasites[0] | |
|
864 | paax = cgax.parasites[1] | |
|
865 | cbar = plt.gcf().colorbar(pm, pad=0.075) | |
|
866 | caax.set_xlabel('x_range [km]') | |
|
867 | caax.set_ylabel('y_range [km]') | |
|
868 | 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') | |
|
869 | ||
|
870 | self.ini= self.ini+1 | |
|
871 | ||
|
872 | ||
|
873 | 928 | ''' |
|
874 | 929 | #-------------------------------------------------------- |
|
930 | print('weather',data['weather'].shape) | |
|
931 | print('ele',data['ele'].shape) | |
|
875 | 932 | |
|
876 |
|
|
|
877 |
|
|
|
933 | 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) | |
|
934 | self.res_azi = numpy.mean(data['azi']) | |
|
935 | print("self.res_ele",self.res_ele) | |
|
878 | 936 | #------------- |
|
879 | 937 | # 90 angulos en el axis 0 |
|
880 | 938 | # 1000 step en el axis 1 |
|
881 | self.res_weather = numpy.ones([120,1000]) | |
|
882 | r = numpy.linspace(0,1999,1000) | |
|
883 | self.res_ele = numpy.arange(0,120) | |
|
884 | self.res_azi = 240 | |
|
939 | ###self.res_weather = numpy.ones([120,1000]) | |
|
940 | ###r = numpy.linspace(0,1999,1000) | |
|
941 | ###self.res_ele = numpy.arange(0,120) | |
|
942 | ###self.res_azi = 240 | |
|
885 | 943 | #------------- |
|
944 | ''' | |
|
886 | 945 | for i,ax in enumerate(self.axes): |
|
887 | 946 | if ax.firsttime: |
|
888 | 947 | plt.clf() |
|
889 | 948 | cgax, pm = wrl.vis.plot_rhi(self.res_weather,r=r,th=self.res_ele,fig=self.figures[0], proj='cg') |
|
890 | 949 | else: |
|
891 | 950 | plt.clf() |
|
892 | 951 | cgax, pm = wrl.vis.plot_rhi(self.res_weather,r=r,th=self.res_ele,fig=self.figures[0], proj='cg') |
|
893 | 952 | caax = cgax.parasites[0] |
|
894 | 953 | paax = cgax.parasites[1] |
|
895 | 954 | cbar = plt.gcf().colorbar(pm, pad=0.075) |
|
896 | 955 | caax.set_xlabel('x_range [km]') |
|
897 | 956 | caax.set_ylabel('y_range [km]') |
|
898 | 957 | 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') |
|
899 | ||
|
958 | ''' | |
|
959 | print("""""""""""""self.ini""""""""""""",self.ini) | |
|
900 | 960 | self.ini= self.ini+1 |
|
1 | NO CONTENT: modified file | |
The requested commit or file is too big and content was truncated. Show full diff |
@@ -1,262 +1,262 | |||
|
1 | 1 | #!python |
|
2 | 2 | ''' |
|
3 | 3 | ''' |
|
4 | 4 | |
|
5 | 5 | import os, sys |
|
6 | 6 | import datetime |
|
7 | 7 | import time |
|
8 | 8 | |
|
9 | 9 | #path = os.path.dirname(os.getcwd()) |
|
10 | 10 | #path = os.path.dirname(path) |
|
11 | 11 | #sys.path.insert(0, path) |
|
12 | 12 | |
|
13 | 13 | from schainpy.controller import Project |
|
14 | 14 | |
|
15 | 15 | desc = "USRP_test" |
|
16 | 16 | filename = "USRP_processing.xml" |
|
17 | 17 | controllerObj = Project() |
|
18 | 18 | controllerObj.setup(id = '191', name='Test_USRP', description=desc) |
|
19 | 19 | |
|
20 | 20 | ############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA ############# |
|
21 | 21 | |
|
22 | 22 | ####################################################################### |
|
23 | 23 | ######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB################# |
|
24 | 24 | ####################################################################### |
|
25 | 25 | #path = '/media/data/data/vientos/57.2063km/echoes/NCO_Woodman' |
|
26 | 26 | #path = '/DATA_RM/TEST_INTEGRACION' |
|
27 | 27 | #path = '/DATA_RM/TEST_ONLINE' |
|
28 | 28 | #path ="/DATA_RM/TEST_LU_21_10M/NOISE_LNA_ON_TX_OFF" |
|
29 | 29 | #path ="/DATA_RM/TEST_LU_21_10M/NOISE_LNA_OFF_TX_OFF" |
|
30 | 30 | path = "/DATA_RM/TEST_MARTES_22_4M_1us" |
|
31 | 31 | figpath = '/home/soporte/Pictures/TEST_MAR_22_4M_1us' |
|
32 | 32 | #path = "/DATA_RM/TEST_MARTES_22_2M_1us" |
|
33 | 33 | #figpath = '/home/soporte/Pictures/TEST_MAR_22_2M_1us' |
|
34 | 34 | |
|
35 | 35 | #path = "/DATA_RM/TEST_MARTES_22_1M_1us" |
|
36 | 36 | #figpath = '/home/soporte/Pictures/TEST_MAR_22_1M_1us' |
|
37 | 37 | #remotefolder = "/home/wmaster/graficos" |
|
38 | 38 | ####################################################################### |
|
39 | 39 | ################# RANGO DE PLOTEO###################################### |
|
40 | 40 | ####################################################################### |
|
41 | 41 | dBmin = '20' |
|
42 | 42 | dBmax = '80' |
|
43 | 43 | xmin = '16' |
|
44 | 44 | xmax ='18' |
|
45 | 45 | ymin = '0' |
|
46 | 46 | ymax = '600' |
|
47 | 47 | ####################################################################### |
|
48 | 48 | ########################FECHA########################################## |
|
49 | 49 | ####################################################################### |
|
50 | 50 | str = datetime.date.today() |
|
51 | 51 | today = str.strftime("%Y/%m/%d") |
|
52 | 52 | str2 = str - datetime.timedelta(days=1) |
|
53 | 53 | yesterday = str2.strftime("%Y/%m/%d") |
|
54 | 54 | ####################################################################### |
|
55 | 55 | ######################## UNIDAD DE LECTURA############################# |
|
56 | 56 | ####################################################################### |
|
57 | 57 | readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader', |
|
58 | 58 | path=path, |
|
59 | 59 | startDate="2022/03/22",#today, |
|
60 | 60 | endDate="2022/03/22",#today, |
|
61 | 61 | startTime='00:00:00', |
|
62 | 62 | endTime='23:59:59', |
|
63 | 63 | delay=0, |
|
64 | 64 | #set=0, |
|
65 | 65 | online=0, |
|
66 | 66 | walk=1, |
|
67 | 67 | ippKm = 60) |
|
68 | 68 | |
|
69 | 69 | opObj11 = readUnitConfObj.addOperation(name='printInfo') |
|
70 | 70 | #opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock') |
|
71 | 71 | ####################################################################### |
|
72 | 72 | ################ OPERACIONES DOMINIO DEL TIEMPO######################## |
|
73 | 73 | ####################################################################### |
|
74 | 74 | |
|
75 | 75 | procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId()) |
|
76 | 76 | # |
|
77 | 77 | # codigo64='1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0,'+\ |
|
78 | 78 | # '1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1' |
|
79 | 79 | |
|
80 | 80 | #opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency') |
|
81 | 81 | #opObj11.addParameter(name='frequency', value='70312500') |
|
82 | 82 | opObj11 = procUnitConfObjA.addOperation(name='selectHeights') |
|
83 | 83 | opObj11.addParameter(name='minIndex', value='1', format='int') |
|
84 | 84 | # opObj11.addParameter(name='maxIndex', value='10000', format='int') |
|
85 | 85 | opObj11.addParameter(name='maxIndex', value='200', format='int') |
|
86 | 86 | |
|
87 | 87 | |
|
88 | 88 | |
|
89 | 89 | ''' |
|
90 | 90 | opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other') |
|
91 | 91 | opObj11.addParameter(name='n', value='625', format='int')#10 |
|
92 | 92 | opObj11.addParameter(name='removeDC', value=1, format='int') |
|
93 | 93 | ''' |
|
94 | 94 | |
|
95 | 95 | # Ploteo TEST |
|
96 | 96 | ''' |
|
97 | 97 | opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other') |
|
98 | 98 | opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other') |
|
99 | 99 | opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other') |
|
100 | 100 | #opObj11.addParameter(name='xmax', value=8) |
|
101 | 101 | opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other') |
|
102 | 102 | ''' |
|
103 | 103 | # OJO SCOPE |
|
104 | 104 | #opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external') |
|
105 | 105 | #opObj10.addParameter(name='id', value='10', format='int') |
|
106 | 106 | ##opObj10.addParameter(name='xmin', value='0', format='int') |
|
107 | 107 | ##opObj10.addParameter(name='xmax', value='50', format='int') |
|
108 | 108 | #opObj10.addParameter(name='type', value='iq') |
|
109 | 109 | ##opObj10.addParameter(name='ymin', value='-5000', format='int') |
|
110 | 110 | ##opObj10.addParameter(name='ymax', value='8500', format='int') |
|
111 | 111 | #opObj11.addParameter(name='save', value=figpath, format='str') |
|
112 | 112 | #opObj11.addParameter(name='save_period', value=10, format='int') |
|
113 | 113 | |
|
114 | 114 | #opObj10 = procUnitConfObjA.addOperation(name='setH0') |
|
115 | 115 | #opObj10.addParameter(name='h0', value='-5000', format='float') |
|
116 | 116 | |
|
117 | 117 | #opObj11 = procUnitConfObjA.addOperation(name='filterByHeights') |
|
118 | 118 | #opObj11.addParameter(name='window', value='1', format='int') |
|
119 | 119 | |
|
120 | 120 | #codigo='1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,1,-1,-1,-1' |
|
121 | 121 | #opObj11 = procUnitConfObjSousy.addOperation(name='Decoder', optype='other') |
|
122 | 122 | #opObj11.addParameter(name='code', value=codigo, format='floatlist') |
|
123 | 123 | #opObj11.addParameter(name='nCode', value='1', format='int') |
|
124 | 124 | #opObj11.addParameter(name='nBaud', value='28', format='int') |
|
125 | 125 | |
|
126 | 126 | #opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other') |
|
127 | 127 | #opObj11.addParameter(name='n', value='100', format='int') |
|
128 | 128 | |
|
129 | 129 | ####################################################################### |
|
130 | 130 | ########## OPERACIONES ParametersProc######################## |
|
131 | 131 | ####################################################################### |
|
132 | 132 | ###procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId()) |
|
133 | 133 | ''' |
|
134 | 134 | |
|
135 | 135 | opObj11 = procUnitConfObjA.addOperation(name='PedestalInformation') |
|
136 | 136 | opObj11.addParameter(name='path_ped', value=path_ped) |
|
137 | 137 | opObj11.addParameter(name='path_adq', value=path_adq) |
|
138 | 138 | opObj11.addParameter(name='t_Interval_p', value='0.01', format='float') |
|
139 | 139 | opObj11.addParameter(name='n_Muestras_p', value='100', format='float') |
|
140 | 140 | opObj11.addParameter(name='blocksPerfile', value='100', format='int') |
|
141 | 141 | opObj11.addParameter(name='f_a_p', value='25', format='int') |
|
142 | 142 | opObj11.addParameter(name='online', value='0', format='int') |
|
143 | 143 | |
|
144 | 144 | opObj11 = procUnitConfObjA.addOperation(name='Block360') |
|
145 | 145 | opObj11.addParameter(name='n', value='40', format='int') |
|
146 | 146 | |
|
147 | 147 | opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other') |
|
148 | 148 | opObj11.addParameter(name='save', value=figpath) |
|
149 | 149 | opObj11.addParameter(name='save_period', value=1) |
|
150 | 150 | |
|
151 | 151 | |
|
152 | 152 | ''' |
|
153 | 153 | |
|
154 | 154 | ####################################################################### |
|
155 | 155 | ########## OPERACIONES DOMINIO DE LA FRECUENCIA######################## |
|
156 | 156 | ####################################################################### |
|
157 | 157 | |
|
158 | 158 | procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId()) |
|
159 |
procUnitConfObjB.addParameter(name='nFFTPoints', value=' |
|
|
159 | procUnitConfObjB.addParameter(name='nFFTPoints', value='0', format='int') | |
|
160 | 160 | procUnitConfObjB.addParameter(name='nProfiles', value='250', format='int') |
|
161 | 161 | |
|
162 | 162 | #procUnitConfObjC = controllerObj.addProcUnit(datatype='SpectraHeisProc', inputId=procUnitConfObjA.getId()) |
|
163 | 163 | #procUnitConfObjB.addParameter(name='nFFTPoints', value='64', format='int') |
|
164 | 164 | #procUnitConfObjB.addParameter(name='nProfiles', value='64', format='int') |
|
165 | 165 | #opObj11 = procUnitConfObjC.addOperation(name='IncohInt4SpectraHeis', optype='other') |
|
166 | 166 | #opObj11.addParameter(name='timeInterval', value='8', format='int') |
|
167 | 167 | |
|
168 | 168 | |
|
169 | 169 | #procUnitConfObjB.addParameter(name='pairsList', value='(0,0),(1,1),(0,1)', format='pairsList') |
|
170 | 170 | |
|
171 | 171 | #opObj13 = procUnitConfObjB.addOperation(name='removeDC') |
|
172 | 172 | #opObj13.addParameter(name='mode', value='2', format='int') |
|
173 | 173 | |
|
174 | 174 | #opObj11 = procUnitConfObjB.addOperation(name='IncohInt', optype='other') |
|
175 | 175 | #opObj11.addParameter(name='n', value='8', format='float') |
|
176 | 176 | ####################################################################### |
|
177 | 177 | ########## PLOTEO DOMINIO DE LA FRECUENCIA############################# |
|
178 | 178 | ####################################################################### |
|
179 | 179 | #---- |
|
180 | 180 | """ |
|
181 | 181 | opObj11 = procUnitConfObjC.addOperation(name='SpectraHeisPlot') |
|
182 | 182 | opObj11.addParameter(name='id', value='10', format='int') |
|
183 | 183 | opObj11.addParameter(name='wintitle', value='Spectra_Alturas', format='str') |
|
184 | 184 | #opObj11.addParameter(name='xmin', value=-100000, format='float') |
|
185 | 185 | #opObj11.addParameter(name='xmax', value=100000, format='float') |
|
186 | 186 | #opObj11.addParameter(name='zmin', value=dBmin, format='int') |
|
187 | 187 | #opObj11.addParameter(name='zmax', value=dBmax, format='int') |
|
188 | 188 | opObj11.addParameter(name='ymin', value=-20, format='int') |
|
189 | 189 | opObj11.addParameter(name='ymax', value=50, format='int') |
|
190 | 190 | opObj11.addParameter(name='showprofile', value='1', format='int') |
|
191 | 191 | opObj11.addParameter(name='save', value=figpath, format='str') |
|
192 | 192 | opObj11.addParameter(name='save_period', value=10, format='int') |
|
193 | 193 | """ |
|
194 | 194 | |
|
195 | 195 | #SpectraPlot |
|
196 | 196 | |
|
197 | 197 | opObj11 = procUnitConfObjB.addOperation(name='SpectraPlot', optype='external') |
|
198 | 198 | opObj11.addParameter(name='id', value='1', format='int') |
|
199 | 199 | opObj11.addParameter(name='wintitle', value='Spectra', format='str') |
|
200 | 200 | #opObj11.addParameter(name='xmin', value=-0.01, format='float') |
|
201 | 201 | #opObj11.addParameter(name='xmax', value=0.01, format='float') |
|
202 | 202 | opObj11.addParameter(name='zmin', value=dBmin, format='int') |
|
203 | 203 | opObj11.addParameter(name='zmax', value=dBmax, format='int') |
|
204 | 204 | #opObj11.addParameter(name='ymin', value=ymin, format='int') |
|
205 | 205 | #opObj11.addParameter(name='ymax', value=ymax, format='int') |
|
206 | 206 | opObj11.addParameter(name='showprofile', value='1', format='int') |
|
207 | 207 | opObj11.addParameter(name='save', value=figpath, format='str') |
|
208 | 208 | opObj11.addParameter(name='save_period', value=10, format='int') |
|
209 | 209 | |
|
210 | 210 | #RTIPLOT |
|
211 | 211 | |
|
212 | 212 | opObj11 = procUnitConfObjB.addOperation(name='RTIPlot', optype='external') |
|
213 | 213 | opObj11.addParameter(name='id', value='2', format='int') |
|
214 | 214 | opObj11.addParameter(name='wintitle', value='RTIPlot', format='str') |
|
215 | 215 | opObj11.addParameter(name='zmin', value=dBmin, format='int') |
|
216 | 216 | opObj11.addParameter(name='zmax', value=dBmax, format='int') |
|
217 | 217 | #opObj11.addParameter(name='ymin', value=ymin, format='int') |
|
218 | 218 | #opObj11.addParameter(name='ymax', value=ymax, format='int') |
|
219 | 219 | opObj11.addParameter(name='xmin', value=xmin, format='int') |
|
220 | 220 | opObj11.addParameter(name='xmax', value=xmax, format='int') |
|
221 | 221 | |
|
222 | 222 | opObj11.addParameter(name='showprofile', value='1', format='int') |
|
223 | 223 | opObj11.addParameter(name='save', value=figpath, format='str') |
|
224 | 224 | opObj11.addParameter(name='save_period', value=10, format='int') |
|
225 | 225 | |
|
226 | 226 | |
|
227 | 227 | # opObj11 = procUnitConfObjB.addOperation(name='CrossSpectraPlot', optype='other') |
|
228 | 228 | # opObj11.addParameter(name='id', value='3', format='int') |
|
229 | 229 | # opObj11.addParameter(name='wintitle', value='CrossSpectraPlot', format='str') |
|
230 | 230 | # opObj11.addParameter(name='ymin', value=ymin, format='int') |
|
231 | 231 | # opObj11.addParameter(name='ymax', value=ymax, format='int') |
|
232 | 232 | # opObj11.addParameter(name='phase_cmap', value='jet', format='str') |
|
233 | 233 | # opObj11.addParameter(name='zmin', value=dBmin, format='int') |
|
234 | 234 | # opObj11.addParameter(name='zmax', value=dBmax, format='int') |
|
235 | 235 | # opObj11.addParameter(name='figpath', value=figures_path, format='str') |
|
236 | 236 | # opObj11.addParameter(name='save', value=0, format='bool') |
|
237 | 237 | # opObj11.addParameter(name='pairsList', value='(0,1)', format='pairsList') |
|
238 | 238 | # # |
|
239 | 239 | # opObj11 = procUnitConfObjB.addOperation(name='CoherenceMap', optype='other') |
|
240 | 240 | # opObj11.addParameter(name='id', value='4', format='int') |
|
241 | 241 | # opObj11.addParameter(name='wintitle', value='Coherence', format='str') |
|
242 | 242 | # opObj11.addParameter(name='phase_cmap', value='jet', format='str') |
|
243 | 243 | # opObj11.addParameter(name='xmin', value=xmin, format='float') |
|
244 | 244 | # opObj11.addParameter(name='xmax', value=xmax, format='float') |
|
245 | 245 | # opObj11.addParameter(name='figpath', value=figures_path, format='str') |
|
246 | 246 | # opObj11.addParameter(name='save', value=0, format='bool') |
|
247 | 247 | # opObj11.addParameter(name='pairsList', value='(0,1)', format='pairsList') |
|
248 | 248 | # |
|
249 | 249 | |
|
250 | 250 | ''' |
|
251 | 251 | ####################################################################### |
|
252 | 252 | ############### UNIDAD DE ESCRITURA ################################### |
|
253 | 253 | ####################################################################### |
|
254 | 254 | #opObj11 = procUnitConfObjB.addOperation(name='SpectraWriter', optype='other') |
|
255 | 255 | #opObj11.addParameter(name='path', value=wr_path) |
|
256 | 256 | #opObj11.addParameter(name='blocksPerFile', value='50', format='int') |
|
257 | 257 | print ("Escribiendo el archivo XML") |
|
258 | 258 | print ("Leyendo el archivo XML") |
|
259 | 259 | ''' |
|
260 | 260 | |
|
261 | 261 | |
|
262 | 262 | controllerObj.start() |
@@ -1,132 +1,133 | |||
|
1 | 1 | # Ing-AlexanderValdez |
|
2 | 2 | # Monitoreo de Pedestal |
|
3 | 3 | |
|
4 | 4 | ############## IMPORTA LIBRERIAS ################### |
|
5 | 5 | import os,numpy,h5py |
|
6 | 6 | import sys,time |
|
7 | 7 | import matplotlib.pyplot as plt |
|
8 | 8 | #################################################### |
|
9 | 9 | ################################################################# |
|
10 | 10 | # LA FECHA 21-10-20 CORRESPONDE A LAS PRUEBAS DEL DIA MIERCOLES |
|
11 | 11 | # 1:15:51 pm hasta 3:49:32 pm |
|
12 | 12 | ################################################################# |
|
13 | 13 | |
|
14 | 14 | #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211012-082745' |
|
15 | 15 | #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211020-131248' |
|
16 | 16 | #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211110-171003' |
|
17 | 17 | #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211111-173856' |
|
18 | 18 | #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211123-143826' |
|
19 | 19 | #path_ped = "/DATA_RM/TEST_PEDESTAL/P20220217-172216" |
|
20 | 20 | #path_ped = "/DATA_RM/TEST_PEDESTAL/P20220322-163824" |
|
21 | 21 | #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211111-173409' |
|
22 | 22 | |
|
23 | 23 | |
|
24 | 24 | #-------------------------------- |
|
25 | 25 | |
|
26 | 26 | path_ped= "/DATA_RM/TEST_PEDESTAL/P20220401-172744" |
|
27 | ||
|
27 | 28 | # Metodo para verificar numero |
|
28 | 29 | def isNumber(str): |
|
29 | 30 | try: |
|
30 | 31 | float(str) |
|
31 | 32 | return True |
|
32 | 33 | except: |
|
33 | 34 | return False |
|
34 | 35 | # Metodo para extraer el arreglo |
|
35 | 36 | def getDatavaluefromDirFilename(path,file,value): |
|
36 | 37 | dir_file= path+"/"+file |
|
37 | 38 | fp = h5py.File(dir_file,'r') |
|
38 | 39 | array = fp['Data'].get(value)[()] |
|
39 | 40 | fp.close() |
|
40 | 41 | return array |
|
41 | 42 | |
|
42 | 43 | # LISTA COMPLETA DE ARCHIVOS HDF5 Pedestal |
|
43 | 44 | LIST= sorted(os.listdir(path_ped)) |
|
44 | 45 | m=len(LIST) |
|
45 | 46 | print("TOTAL DE ARCHIVOS DE PEDESTAL:",m) |
|
46 | 47 | # Contadores temporales |
|
47 | 48 | k= 0 |
|
48 | 49 | l= 0 |
|
49 | 50 | t= 0 |
|
50 | 51 | # Marca de tiempo temporal |
|
51 | 52 | time_ = numpy.zeros([m]) |
|
52 | 53 | # creacion de |
|
53 | 54 | for i in range(m): |
|
54 | 55 | print("order:",i) |
|
55 | 56 | tmp_azi_pos = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="azi_pos") |
|
56 | 57 | tmp_ele_pos = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="ele_pos") |
|
57 | 58 | tmp_azi_vel = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="azi_vel") |
|
58 | 59 | tmp_ele_vel = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="ele_vel")# nuevo :D |
|
59 | 60 | |
|
60 | 61 | time_[i] = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="utc") |
|
61 | 62 | |
|
62 | 63 | k=k +tmp_azi_pos.shape[0] |
|
63 | 64 | l=l +tmp_ele_pos.shape[0] |
|
64 | 65 | t=t +tmp_azi_vel.shape[0] |
|
65 | 66 | |
|
66 | 67 | print("TOTAL DE MUESTRAS, ARCHIVOS X100:",k) |
|
67 | 68 | time.sleep(5) |
|
68 | 69 | ######CREACION DE ARREGLOS CANTIDAD DE VALORES POR MUESTRA################# |
|
69 | 70 | azi_pos = numpy.zeros([k]) |
|
70 | 71 | ele_pos = numpy.zeros([l]) |
|
71 | 72 | time_azi_pos= numpy.zeros([k]) |
|
72 | 73 | # Contadores temporales |
|
73 | 74 | p=0 |
|
74 | 75 | r=0 |
|
75 | 76 | z=0 |
|
76 | 77 | # VARIABLES TMP para almacenar azimuth, elevacion y tiempo |
|
77 | 78 | |
|
78 | 79 | #for filename in sorted(os.listdir(path_ped)): |
|
79 | 80 | # CONDICION POR LEER EN TIEMPO REAL NO OFFLINE |
|
80 | 81 | |
|
81 | 82 | for filename in LIST: |
|
82 | tmp_azi_pos = getDatavaluefromDirFilename(path=path_ped,file=filename,value="azi_pos") | |
|
83 | #tmp_azi_pos = getDatavaluefromDirFilename(path=path_ped,file=filename,value="azi_pos") | |
|
83 | 84 | tmp_ele_pos = getDatavaluefromDirFilename(path=path_ped,file=filename,value="ele_pos") |
|
84 |
|
|
|
85 | tmp_azi_pos = getDatavaluefromDirFilename(path=path_ped,file=filename,value="ele_vel") | |
|
85 | 86 | #tmp_ele_pos = getDatavaluefromDirFilename(path=path_ped,file=filename,value="azi_vel") |
|
86 | 87 | # CONDICION POR LEER EN TIEMPO REAL NO OFFLINE |
|
87 | 88 | |
|
88 | 89 | if z==(m-1): |
|
89 | 90 | tmp_azi_time=numpy.arange(time_[z],time_[z]+1,1/(tmp_azi_pos.shape[0])) |
|
90 | 91 | else: |
|
91 | 92 | tmp_azi_time=numpy.arange(time_[z],time_[z+1],(time_[z+1]-time_[z])/(tmp_azi_pos.shape[0])) |
|
92 | 93 | |
|
93 | 94 | print(filename,time_[z]) |
|
94 | 95 | print(z,tmp_azi_pos.shape[0]) |
|
95 | 96 | |
|
96 | 97 | i=0 |
|
97 | 98 | for i in range(tmp_azi_pos.shape[0]): |
|
98 | 99 | index=p+i |
|
99 | 100 | azi_pos[index]=tmp_azi_pos[i] |
|
100 | 101 | time_azi_pos[index]=tmp_azi_time[i] |
|
101 | 102 | p=p+tmp_azi_pos.shape[0] |
|
102 | 103 | i=0 |
|
103 | 104 | for i in range(tmp_ele_pos.shape[0]): |
|
104 | 105 | index=r+i |
|
105 | 106 | ele_pos[index]=tmp_ele_pos[i] |
|
106 | 107 | r=r+tmp_ele_pos.shape[0] |
|
107 | 108 | |
|
108 | 109 | |
|
109 | 110 | z+=1 |
|
110 | 111 | |
|
111 | 112 | |
|
112 | 113 | ######## GRAFIQUEMOS Y VEAMOS LOS DATOS DEL Pedestal |
|
113 | 114 | fig, ax = plt.subplots(figsize=(16,8)) |
|
114 | 115 | print(time_azi_pos.shape) |
|
115 | 116 | print(azi_pos.shape) |
|
116 | 117 | t=numpy.arange(time_azi_pos.shape[0])*0.01/(60.0) |
|
117 | 118 | plt.plot(t,azi_pos,label='AZIMUTH_POS',color='blue') |
|
118 | 119 | |
|
119 | 120 | # AQUI ESTOY ADICIONANDO LA POSICION EN elevaciont=numpy.arange(len(ele_pos))*0.01/60.0 |
|
120 | 121 | t=numpy.arange(len(ele_pos))*0.01/60.0 |
|
121 | 122 | plt.plot(t,ele_pos,label='ELEVATION_POS',color='red')#*10 |
|
122 | 123 | |
|
123 | 124 | ax.set_xlim(0, 4) |
|
124 | 125 | ax.set_ylim(-5, 360) |
|
125 | 126 | plt.ylabel("Azimuth Position") |
|
126 | 127 | plt.xlabel("Muestra") |
|
127 | 128 | plt.title('Azimuth Position vs Muestra ', fontsize=20) |
|
128 | 129 | axes = plt.gca() |
|
129 | 130 | axes.yaxis.grid() |
|
130 | 131 | plt.xticks(fontsize=16) |
|
131 | 132 | plt.yticks(fontsize=16) |
|
132 | 133 | plt.show() |
@@ -1,58 +1,72 | |||
|
1 | 1 | import numpy as np |
|
2 | 2 | import matplotlib.pyplot as plt |
|
3 | 3 | import wradlib as wrl |
|
4 | 4 | import warnings |
|
5 | 5 | # libreia nueva |
|
6 | 6 | #export WRADLIB_DATA="/home/soporte/Downloads/2014-06-09--185000.rhi.mvol" |
|
7 | 7 | from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter |
|
8 | 8 | warnings.filterwarnings('ignore') |
|
9 | 9 | # lectura de gaMIC hdf5 file |
|
10 | 10 | filename = wrl.util.get_wradlib_data_file("/home/soporte/Downloads/2014-06-09--185000.rhi.mvol") |
|
11 | #filename = wrl.util.get_wradlib_data_file("2014-06-09--185000.rhi.mvol") | |
|
12 | ||
|
11 | 13 | data1, metadata = wrl.io.read_gamic_hdf5(filename) |
|
12 | 14 | print(data1) |
|
13 | 15 | data1 = data1['SCAN0']['ZH']['data'] |
|
14 | 16 | print(data1) |
|
15 | 17 | print("SHAPE Data",np.array(data1).shape) |
|
16 | 18 | r = metadata['SCAN0']['r'] |
|
17 | 19 | print("r",r) |
|
18 | 20 | print("longitud r",len(r)) |
|
19 | 21 | th = metadata['SCAN0']['el'] |
|
20 | 22 | print("th",th) |
|
21 | 23 | print("longitud th",len(th)) |
|
22 | 24 | az = metadata['SCAN0']['az'] |
|
23 | 25 | print("az",az) |
|
24 | 26 | site = (metadata['VOL']['Longitude'], metadata['VOL']['Latitude'], |
|
25 | 27 | metadata['VOL']['Height']) |
|
26 | 28 | |
|
27 | 29 | print("Longitud,Latitud,Altura",site) |
|
28 | 30 | ma1 = np.array(data1) |
|
31 | for i in range(3): | |
|
32 | print("dark",ma1[i]) | |
|
29 | 33 | ''' |
|
30 | 34 | mask_ind = np.where(data1 <= np.nanmin(data1)) |
|
31 | 35 | data1[mask_ind] = np.nan |
|
32 | 36 | ma1 = np.ma.array(data1, mask=np.isnan(data1)) |
|
33 | 37 | ''' |
|
38 | ####################### test ####################s | |
|
39 | th=(np.arange(450)/10.0)+5 | |
|
40 | #th= np.roll(th,-2) | |
|
41 | #th=np.where(a<7,np.nan,a) | |
|
42 | ma1=np.roll(ma1,-2,axis=0) | |
|
43 | for i in range(3): | |
|
44 | print("green",ma1[i]) | |
|
45 | print("a",th) | |
|
46 | #th = [i for i in reversed(a)] | |
|
47 | ######################### test | |
|
34 | 48 | #cgax, pm = wrl.vis.plot_rhi(ma1,r=r,th=th,rf=1e3) |
|
35 | 49 | fig = plt.figure(figsize=(10,8)) |
|
36 | 50 | cgax, pm = wrl.vis.plot_rhi(ma1,r=r,th=th,rf=1e3,fig=fig, ax=111,proj='cg') |
|
37 | 51 | caax = cgax.parasites[0] |
|
38 | 52 | paax = cgax.parasites[1] |
|
39 | 53 | cgax.set_ylim(0, 14) |
|
40 | 54 | #caax = cgax.parasites[0] |
|
41 | 55 | #paax = cgax.parasites[1] |
|
42 | 56 | #cgax, pm = wrl.vis.plot_rhi(ma1, r=r, th=th, rf=1e3, fig=fig, ax=111, proj='cg') |
|
43 | 57 | txt = plt.title('Simple RHI',y=1.05) |
|
44 | 58 | #cbar = plt.gcf().colorbar(pm, pad=0.05, ax=paax) |
|
45 | 59 | cbar = plt.gcf().colorbar(pm, pad=0.05) |
|
46 | 60 | cbar.set_label('reflectivity [dBZ]') |
|
47 | 61 | caax.set_xlabel('x_range [km]') |
|
48 | 62 | caax.set_ylabel('y_range [km]') |
|
49 | 63 | plt.text(1.0, 1.05, 'azimuth', transform=caax.transAxes, va='bottom',ha='right') |
|
50 | 64 | gh = cgax.get_grid_helper() |
|
51 | 65 | |
|
52 | 66 | # set theta to some nice values |
|
53 | 67 | locs = [0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., |
|
54 | 68 | 15., 16., 17., 18., 20., 22., 25., 30., 35., 40., 50., 60., 70., 80., 90.] |
|
55 | 69 | gh.grid_finder.grid_locator1 = FixedLocator(locs) |
|
56 | 70 | gh.grid_finder.tick_formatter1 = DictFormatter(dict([(i, r"${0:.0f}^\circ$".format(i)) for i in locs])) |
|
57 | 71 | |
|
58 | 72 | plt.show() |
@@ -1,226 +1,242 | |||
|
1 | 1 | # Ing. AVP |
|
2 | 2 | # 06/10/2021 |
|
3 | 3 | # ARCHIVO DE LECTURA |
|
4 | 4 | import os, sys |
|
5 | 5 | import datetime |
|
6 | 6 | import time |
|
7 | 7 | from schainpy.controller import Project |
|
8 | 8 | #### NOTA########################################### |
|
9 | 9 | # INPUT : |
|
10 | 10 | # VELOCIDAD PARAMETRO : V = 2Β°/seg |
|
11 | 11 | # MODO PULSE PAIR O MOMENTOS: 0 : Pulse Pair ,1 : Momentos |
|
12 | 12 | ###################################################### |
|
13 | 13 | ##### PROCESAMIENTO ################################## |
|
14 | 14 | ##### OJO TENER EN CUENTA EL n= para el Pulse Pair ## |
|
15 | 15 | ##### O EL n= nFFTPoints ### |
|
16 | 16 | ###################################################### |
|
17 | 17 | ######## BUSCAMOS EL numero de IPP equivalente 1Β°##### |
|
18 | 18 | ######## Sea V la velocidad del Pedestal en Β°/seg##### |
|
19 | 19 | ######## 1Β° sera Recorrido en un tiempo de 1/V ###### |
|
20 | 20 | ######## IPP del Radar 400 useg --> 60 Km ############ |
|
21 | 21 | ######## n = 1/(V(Β°/seg)*IPP(Km)) , NUMERO DE IPP ## |
|
22 | 22 | ######## n = 1/(V*IPP) ############################# |
|
23 | 23 | |
|
24 | 24 | #-------------------------VELOCIDAD DEL PEDESTAL Y MODO ------------------------ |
|
25 | 25 | print("SETUP- RADAR METEOROLOGICO") |
|
26 | 26 | IPP = 400*1e-6 |
|
27 | 27 | V = 6 |
|
28 | 28 | samp_rate = 10# VERIFICAR |
|
29 | 29 | MODE_TABLE = 1 # PUEDE SER 1 O 0 |
|
30 | 30 | AXIS = [1,1,1,1] # AZIMUTH 1 ELEVACION 0 |
|
31 | 31 | SPEED_AXIS = [10,10,10,10] # VELOCIDAD |
|
32 | 32 | ANGLE_AXIS = [20,25,30,15] # ANGULOS |
|
33 | 33 | mode_proc = 0 |
|
34 | 34 | #-----------------------------PATH ADQ Y PEDESTAL------------------------------- |
|
35 | 35 | #ath = "/DATA_RM/TEST_MARTES_22_1M_1us" |
|
36 | 36 | #path_ped = "/DATA_RM/TEST_PEDESTAL/P20220322-171722" |
|
37 | 37 | #path = "/DATA_RM/DRONE01ABRIL" |
|
38 | 38 | #path = "/DATA_RM/DRONE01ABRIL1429" |
|
39 | 39 | #path_ped = "/DATA_RM/TEST_PEDESTAL/P20220322-171722" |
|
40 | 40 | #path = "/DATA_RM/DRONE01ABRIL1701" |
|
41 | 41 | path = "/DATA_RM/DATA/Torre_con_bola_1649092242/rawdata" |
|
42 | ||
|
43 | path_ped = "/DATA_RM/DRONE01ABRIL1450" | |
|
42 | path="/DATA_RM/DRONE01ABRIL1727" | |
|
43 | #path_ped = "/DATA_RM/DRONE01ABRIL1450" | |
|
44 | path_ped="/DATA_RM/TEST_PEDESTAL/P20220401-172744" | |
|
45 | #path_ped = "/DATA_RM/DATA/Torre_con_bola_1649092242/position/2022-04-04T17-00-00" | |
|
44 | 46 | #------------------------------------------------------------------------------- |
|
45 | 47 | figpath_pp = "/home/soporte/Pictures/Torre_con_bola_1649092242" |
|
46 | 48 | #figpath_pp = "/home/soporte/Pictures/MARTES_22_PP_1M_1us" |
|
47 | 49 | figpath_spec = "/home/soporte/Pictures/MARTES_22_1M_1us" |
|
48 | 50 | figpath_pp_ppi = "/home/soporte/Pictures/MARTES_22_1M_1us_PPI" |
|
51 | ||
|
52 | ||
|
53 | figpath_pp_rhi = "/DATA_RM/LUNES04ABRIL_1200_RHI" | |
|
49 | 54 | #--------------------------OPCIONES--------------------------------------------- |
|
50 | plot = 1 | |
|
51 | 55 | plot_ppi = 0 |
|
52 | integration = 0 | |
|
56 | plot = 0 | |
|
57 | plot_rhi = 1 | |
|
58 | integration = 1 | |
|
53 | 59 | save = 0 |
|
54 | 60 | plot_spec = 0 |
|
55 | 61 | #---------------------------SAVE HDF5 PROCESADO/-------------------------------- |
|
56 | 62 | if save == 1: |
|
57 | 63 | if mode_proc==0: |
|
58 | 64 | path_save = '/DATA_RM/TEST_HDF5_PP_MAR22/6v' |
|
59 | 65 | else: |
|
60 | 66 | path_save = '/DATA_RM/TEST_HDF5_SPEC_MAR22/6v' |
|
61 | 67 | print("[SETUP]-RADAR METEOROLOGICO-") |
|
62 | 68 | print("* PATH data ADQ :", path) |
|
63 | 69 | print("* PATH data PED :", path_ped) |
|
64 | 70 | print("* SAMPLE RATE ADQ Mhz :", samp_rate) |
|
65 | 71 | print("* Velocidad Pedestal :",V,"Β°/seg") |
|
66 | 72 | print("* Configuracion del Pedestal *") |
|
67 | 73 | |
|
68 | 74 | print("*** AXIS :",AXIS) |
|
69 | 75 | print("*** SPEED_AXIS:",SPEED_AXIS) |
|
70 | 76 | print("*** ANGLE_AXIS:",ANGLE_AXIS) |
|
71 | 77 | num_alturas = int(samp_rate*IPP*1e6) |
|
72 | 78 | print("* Nro de Altura :",num_alturas) |
|
73 | 79 | |
|
74 | 80 | ############################ NRO Perfiles PROCESAMIENTO ################### |
|
75 | 81 | V=V |
|
76 | 82 | n= int(1/(V*IPP)) |
|
77 | 83 | print("* n - NRO Perfiles Proc:", n ) |
|
78 | 84 | ################################## MODE ################################### |
|
79 | 85 | print("* Modo de Operacion :",mode_proc) |
|
80 | 86 | if mode_proc ==0: |
|
81 | 87 | print("* Met. Seleccionado : Pulse Pair") |
|
82 | 88 | else: |
|
83 | 89 | print("* Met. Momentos : Momentos") |
|
84 | 90 | ################################## MODE ################################### |
|
85 | 91 | print("* Grabado de datos :",save) |
|
86 | 92 | if save ==1: |
|
87 | 93 | if mode_proc==0: |
|
88 | 94 | print("[ ON ] MODE PULSEPAIR") |
|
89 | 95 | |
|
90 | 96 | else: |
|
91 | 97 | print("[ ON ] MODE FREQUENCY") |
|
92 | 98 | |
|
93 | 99 | print("* Integracion de datos :",integration) |
|
94 | 100 | |
|
95 | 101 | print("* Ploteo de datos Parameters:", plot) |
|
96 | 102 | if plot==1: |
|
97 | 103 | print("* Path PP plot :", figpath_pp ) |
|
98 | 104 | |
|
99 | 105 | if plot_ppi==1: |
|
100 | 106 | print("* Path PPI plot :", figpath_pp_ppi ) |
|
101 | 107 | |
|
102 | 108 | time.sleep(4) |
|
103 | 109 | #remotefolder = "/home/wmaster/graficos" |
|
104 | 110 | ################# RANGO DE PLOTEO###################################### |
|
105 | 111 | dBmin = '20' |
|
106 | 112 | dBmax = '60' |
|
107 | 113 | xmin = '12.0' #17.1,17.5 |
|
108 | 114 | xmax = '12.4' #17.2,17.8 |
|
109 | 115 | ymin = '0' #### PONER A 0 |
|
110 | 116 | ymax = '1.0' #### PONER A 8 |
|
111 | 117 | ########################FECHA########################################## |
|
112 | 118 | str1 = datetime.date.today() |
|
113 | 119 | today = str1.strftime("%Y/%m/%d") |
|
114 | 120 | str2 = str1 - datetime.timedelta(days=1) |
|
115 | 121 | yesterday = str2.strftime("%Y/%m/%d") |
|
116 | 122 | |
|
117 | 123 | #------------------------SIGNAL CHAIN------------------------------------------- |
|
118 | 124 | desc = "USRP_test" |
|
119 | 125 | filename = "USRP_processing.xml" |
|
120 | 126 | controllerObj = Project() |
|
121 | 127 | controllerObj.setup(id = '191', name='Test_USRP', description=desc) |
|
122 | 128 | #------------------------ UNIDAD DE LECTURA------------------------------------- |
|
123 | 129 | readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader', |
|
124 | 130 | path=path, |
|
125 |
startDate="2022/04/0 |
|
|
126 |
endDate="2022/04/0 |
|
|
127 |
startTime=' |
|
|
131 | startDate="2022/04/01",#today, | |
|
132 | endDate="2022/04/01",#today, | |
|
133 | startTime='00:10:05',#'17:39:25', | |
|
128 | 134 | endTime='23:59:59',#23:59:59', |
|
129 | 135 | delay=0, |
|
130 | 136 | #set=0, |
|
131 | 137 | online=0, |
|
132 | 138 | walk=1, |
|
133 | 139 | ippKm = 60) |
|
134 | 140 | |
|
135 | 141 | opObj11 = readUnitConfObj.addOperation(name='printInfo') |
|
136 | 142 | |
|
137 | 143 | procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId()) |
|
138 | 144 | ''' |
|
139 | 145 | opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external') |
|
140 | 146 | opObj10.addParameter(name='id', value='10', format='int') |
|
141 | 147 | opObj10.addParameter(name='zmin', value='0', format='int') |
|
142 | 148 | opObj10.addParameter(name='zmax', value='3', format='int') |
|
143 | 149 | opObj10.addParameter(name='type', value='iq') |
|
144 | 150 | opObj10.addParameter(name='ymin', value='-1200', format='int') |
|
145 | 151 | opObj10.addParameter(name='ymax', value='1200', format='int') |
|
146 | 152 | #opObj10.addParameter(name='save', value=figpath, format='str') |
|
147 | 153 | opObj10.addParameter(name='save_period', value=10, format='int') |
|
148 | 154 | ''' |
|
149 | 155 | opObj11 = procUnitConfObjA.addOperation(name='setH0') |
|
150 | 156 | opObj11.addParameter(name='h0', value='-1.2', format='float') |
|
151 | 157 | |
|
152 | 158 | opObj11 = procUnitConfObjA.addOperation(name='selectHeights') |
|
153 | 159 | opObj11.addParameter(name='minIndex', value='1', format='int') |
|
154 | 160 | #opObj11.addParameter(name='maxIndex', value='1000', format='int') |
|
155 | 161 | #opObj11.addParameter(name='maxIndex', value=str(int(num_alturas/4.0)), format='int') |
|
156 | 162 | # CUARTA PARTE de 60 Km POR ESO ENTRE 4 - 15 Km |
|
157 | 163 | opObj11.addParameter(name='maxIndex', value=str(int(num_alturas/20.0)), format='int') |
|
158 | 164 | # CUARTA PARTE de 60 Km POR ESO ENTRE 10 - 6 Km |
|
159 | 165 | # CUARTA PARTE de 60 Km POR ESO ENTRE 20 - 3 Km |
|
160 | 166 | |
|
161 | 167 | |
|
162 | ||
|
168 | ''' | |
|
163 | 169 | procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId()) |
|
164 | 170 | procUnitConfObjB.addParameter(name='nFFTPoints', value='32', format='int') |
|
165 | 171 | procUnitConfObjB.addParameter(name='nProfiles', value='32', format='int') |
|
166 | 172 |
|
|
167 | 173 |
|
|
168 | 174 |
|
|
169 | 175 |
|
|
170 | 176 | opObj11 = procUnitConfObjB.addOperation(name='SpectraPlot', optype='external') |
|
171 | 177 | opObj11.addParameter(name='id', value='1', format='int') |
|
172 | 178 | opObj11.addParameter(name='wintitle', value='Spectra', format='str') |
|
173 | 179 |
|
|
174 | 180 |
|
|
175 | 181 | opObj11.addParameter(name='zmin', value=dBmin, format='int') |
|
176 | 182 | opObj11.addParameter(name='zmax', value=dBmax, format='int') |
|
177 | 183 | opObj11.addParameter(name='ymin', value=ymin, format='int') |
|
178 | 184 | opObj11.addParameter(name='ymax', value=ymax, format='int') |
|
179 | 185 | opObj11.addParameter(name='showprofile', value='1', format='int') |
|
180 | 186 |
|
|
181 | 187 | opObj11.addParameter(name='save_period', value=10, format='int') |
|
182 | ||
|
188 | ''' | |
|
183 | 189 | |
|
184 | 190 | if mode_proc ==0: |
|
185 | 191 | ####################### METODO PULSE PAIR ###################################################################### |
|
186 | 192 | opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other') |
|
187 | 193 | opObj11.addParameter(name='n', value=int(n), format='int')#10 VOY A USAR 250 DADO QUE LA VELOCIDAD ES 10 GRADOS |
|
188 | 194 | #opObj11.addParameter(name='removeDC', value=1, format='int') |
|
189 | 195 | ####################### METODO Parametros ###################################################################### |
|
190 | 196 | procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId()) |
|
191 | 197 | if plot==1: |
|
192 | 198 | opObj11 = procUnitConfObjB.addOperation(name='GenericRTIPlot',optype='external') |
|
193 | 199 | opObj11.addParameter(name='attr_data', value='dataPP_POWER') |
|
194 | 200 | opObj11.addParameter(name='colormap', value='jet') |
|
195 | 201 | opObj11.addParameter(name='xmin', value=xmin) |
|
196 | 202 | opObj11.addParameter(name='xmax', value=xmax) |
|
197 | 203 | opObj11.addParameter(name='ymin', value=ymin) |
|
198 | 204 | opObj11.addParameter(name='ymax', value=ymax) |
|
199 | 205 | opObj11.addParameter(name='zmin', value=dBmin) |
|
200 | 206 | opObj11.addParameter(name='zmax', value=dBmax) |
|
201 | 207 | opObj11.addParameter(name='save', value=figpath_pp) |
|
202 | 208 | opObj11.addParameter(name='showprofile', value=0) |
|
203 | 209 | opObj11.addParameter(name='save_period', value=10) |
|
204 | 210 | ####################### METODO ESCRITURA ####################################################################### |
|
205 | 211 | if save==1: |
|
206 | 212 | opObj10 = procUnitConfObjB.addOperation(name='HDFWriter') |
|
207 | 213 | opObj10.addParameter(name='path',value=path_save) |
|
208 | 214 | #opObj10.addParameter(name='mode',value=0) |
|
209 | 215 | opObj10.addParameter(name='blocksPerFile',value='100',format='int') |
|
210 | 216 | opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list') |
|
211 | 217 | opObj10.addParhirameter(name='dataList',value='dataPP_POWER,dataPP_DOP,utctime',format='list')#,format='list' |
|
212 | 218 | if integration==1: |
|
213 | 219 | opObj11 = procUnitConfObjB.addOperation(name='PedestalInformation') |
|
214 | 220 | opObj11.addParameter(name='path_ped', value=path_ped) |
|
215 | 221 | opObj11.addParameter(name='t_Interval_p', value='0.01', format='float') |
|
216 | opObj11.addParameter(name='wr_exp', value='PPI') | |
|
222 | #opObj11.addParameter(name='wr_exp', value='PPI') | |
|
223 | opObj11.addParameter(name='wr_exp', value='RHI') | |
|
224 | ||
|
217 | 225 | if plot_ppi==1: |
|
218 | 226 | opObj11 = procUnitConfObjB.addOperation(name='Block360') |
|
219 | 227 | opObj11.addParameter(name='n', value='10', format='int') |
|
220 | 228 | opObj11.addParameter(name='mode', value=mode_proc, format='int') |
|
221 | 229 | # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180 |
|
222 | 230 | opObj11= procUnitConfObjB.addOperation(name='WeatherPlot',optype='other') |
|
223 | 231 | opObj11.addParameter(name='save', value=figpath_pp_ppi) |
|
224 | 232 | opObj11.addParameter(name='save_period', value=1) |
|
233 | if plot_rhi==1: | |
|
234 | opObj11 = procUnitConfObjB.addOperation(name='Block360') | |
|
235 | opObj11.addParameter(name='n', value='10', format='int') | |
|
236 | opObj11.addParameter(name='mode', value=mode_proc, format='int') | |
|
237 | # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180 | |
|
238 | opObj11= procUnitConfObjB.addOperation(name='WeatherRHIPlot',optype='other') | |
|
239 | opObj11.addParameter(name='save', value=figpath_pp_rhi) | |
|
240 | opObj11.addParameter(name='save_period', value=1) | |
|
225 | 241 | |
|
226 | 242 | controllerObj.start() |
General Comments 0
You need to be logged in to leave comments.
Login now