##// END OF EJS Templates
schain
RSS
borrando metodos innecesarios
avaldezp -
r1408:ae09156e81be
parent child
Show More
Side by Side Unified
Context file:
r1408:ae09156e81be Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,678 +1,678
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
403 403 if hasattr(dataOut, 'nFFTPoints'):
404 404 factor = dataOut.normFactor
405 405
406 406 ####print("factor",factor)
407 407 data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
408 408 ####print("weather",data['weather'])
409 409 data['azi'] = dataOut.data_azi
410 410 return data, meta
411 411
412 412 def get2List(self,angulos):
413 413 list1=[]
414 414 list2=[]
415 415 for i in reversed(range(len(angulos))):
416 416 diff_ = angulos[i]-angulos[i-1]
417 417 if diff_ >1.5:
418 418 list1.append(i-1)
419 419 list2.append(diff_)
420 420 return list(reversed(list1)),list(reversed(list2))
421 421
422 422 def fixData360(self,list_,ang_):
423 423 if list_[0]==-1:
424 424 vec = numpy.where(ang_<ang_[0])
425 425 ang_[vec] = ang_[vec]+360
426 426 return ang_
427 427 return ang_
428 428
429 429
430 430 def fixData360HL(self,angulos):
431 431 vec = numpy.where(angulos>=360)
432 432 angulos[vec]=angulos[vec]-360
433 433 return angulos
434 434
435 435 def search_pos(self,pos,list_):
436 436 for i in range(len(list_)):
437 437 if pos == list_[i]:
438 438 return True,i
439 439 i=None
440 440 return False,i
441 441
442 442 def fixDataComp(self,ang_,list1_,list2_):
443 443 size = len(ang_)
444 444 size2 = 0
445 445 for i in range(len(list2_)):
446 446 size2=size2+list2_[i]-1
447 447 new_size= size+size2
448 448 ang_new = numpy.zeros(new_size)
449 449 ang_new2 = numpy.zeros(new_size)
450 450
451 451 tmp = 0
452 452 c = 0
453 453 for i in range(len(ang_)):
454 454 ang_new[tmp +c] = ang_[i]
455 455 ang_new2[tmp+c] = ang_[i]
456 456 condition , value = self.search_pos(i,list1_)
457 457 if condition:
458 458 pos = tmp + c + 1
459 459 for k in range(list2_[value]-1):
460 460 ang_new[pos+k] = ang_new[pos+k-1]+1
461 461 ang_new2[pos+k] = numpy.nan
462 462 tmp = pos +k
463 463 c = 0
464 464 c=c+1
465 465 return ang_new,ang_new2
466 466
467 467
468 468 def globalCheckPED(self,angulos):
469 469 l1,l2 = self.get2List(angulos)
470 470 if len(l1)>0:
471 471 angulos2 = self.fixData360(list_=l1,ang_=angulos)
472 472 l1,l2 = self.get2List(angulos2)
473 473
474 474 ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2)
475 475 ang1_ = self.fixData360HL(ang1_)
476 476 ang2_ = self.fixData360HL(ang2_)
477 477
478 478 else:
479 479 ang1_= angulos
480 480 ang2_= angulos
481 481 return ang1_,ang2_
482 482
483 483 def analizeDATA(self,data_azi):
484 484 list1 = []
485 485 list2 = []
486 486 dat = data_azi
487 487 for i in reversed(range(1,len(dat))):
488 488 if dat[i]>dat[i-1]:
489 489 diff = int(dat[i])-int(dat[i-1])
490 490 else:
491 491 diff = 360+int(dat[i])-int(dat[i-1])
492 492 if diff > 1:
493 493 list1.append(i-1)
494 494 list2.append(diff-1)
495 495 return list1,list2
496 496
497 497 def fixDATANEW(self,data_azi,data_weather):
498 498 list1,list2 = self.analizeDATA(data_azi)
499 499 if len(list1)== 0:
500 500 return data_azi,data_weather
501 501 else:
502 502 resize = 0
503 503 for i in range(len(list2)):
504 504 resize= resize + list2[i]
505 505 new_data_azi = numpy.resize(data_azi,resize)
506 506 new_data_weather= numpy.resize(date_weather,resize)
507 507
508 508 for i in range(len(list2)):
509 509 j=0
510 510 position=list1[i]+1
511 511 for j in range(list2[i]):
512 512 new_data_azi[position+j]=new_data_azi[position+j-1]+1
513 513
514 514 return new_data_azi
515 515
516 516 def fixDATA(self,data_azi):
517 517 data=data_azi
518 518 for i in range(len(data)):
519 519 if numpy.isnan(data[i]):
520 520 data[i]=data[i-1]+1
521 521 return data
522 522
523 523 def replaceNAN(self,data_weather,data_azi,val):
524 524 ####print("----------------activeNEWFUNCTION")
525 525 data= data_azi
526 526 data_T= data_weather
527 527 ####print("data_azi",data_azi)
528 528 ####print("VAL:",val)
529 529 ####print("SHAPE",data_T.shape)
530 530 for i in range(len(data)):
531 531 if numpy.isnan(data[i]):
532 532 ####print("NAN")
533 data_T[i,:]=numpy.ones(data_T.shape[1])*val
534 #data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
533 #data_T[i,:]=numpy.ones(data_T.shape[1])*val
534 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
535 535 return data_T
536 536
537 537 def const_ploteo(self,data_weather,data_azi,step,res):
538 538 if self.ini==0:
539 539 #------- AZIMUTH
540 540 n = (360/res)-len(data_azi)
541 541 #--------------------- new -------------------------
542 542 ####data_azi_old = data_azi
543 543 data_azi_new ,data_azi_old= self.globalCheckPED(data_azi)
544 544 #------------------------
545 545 ####data_azi_new = self.fixDATA(data_azi)
546 546 #ata_azi_new = self.fixDATANEW(data_azi)
547 547
548 548 start = data_azi_new[-1] + res
549 549 end = data_azi_new[0] - res
550 550 ##### new
551 551 self.last_data_azi = end
552 552 if start>end:
553 553 end = end + 360
554 554 azi_vacia = numpy.linspace(start,end,int(n))
555 555 azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia)
556 556 data_azi = numpy.hstack((data_azi_new,azi_vacia))
557 557 # RADAR
558 558 val_mean = numpy.mean(data_weather[:,-1])
559 559 self.val_mean = val_mean
560 560 data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
561 561 data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
562 562 data_weather = numpy.vstack((data_weather,data_weather_cmp))
563 563 else:
564 564 # azimuth
565 565 flag=0
566 566 start_azi = self.res_azi[0]
567 567 #-----------new------------
568 568 data_azi ,data_azi_old= self.globalCheckPED(data_azi)
569 569 data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
570 570 #--------------------------
571 571 ####data_azi_old = data_azi
572 572 ### weather ###
573 573 ####data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
574 574
575 575 ####if numpy.isnan(data_azi[0]):
576 576 #### data_azi[0]=self.last_data_azi+1
577 577 ####data_azi = self.fixDATA(data_azi)
578 578 start = data_azi[0]
579 579 end = data_azi[-1]
580 580 self.last_data_azi= end
581 581 ####print("start",start)
582 582 ####print("end",end)
583 583 if start< start_azi:
584 584 start = start +360
585 585 if end <start_azi:
586 586 end = end +360
587 587 ####print("start",start)
588 588 ####print("end",end)
589 589 #### AQUI SERA LA MAGIA
590 590 pos_ini = int((start-start_azi)/res)
591 591 len_azi = len(data_azi)
592 592 if (360-pos_ini)<len_azi:
593 593 if pos_ini+1==360:
594 594 pos_ini=0
595 595 else:
596 596 flag=1
597 597 dif= 360-pos_ini
598 598 comp= len_azi-dif
599 599
600 600 #-----------------
601 601 ####print(pos_ini)
602 602 ####print(len_azi)
603 603 ####print("shape",self.res_azi.shape)
604 604 if flag==0:
605 605 # AZIMUTH
606 606 self.res_azi[pos_ini:pos_ini+len_azi] = data_azi
607 607 # RADAR
608 608 self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather
609 609 else:
610 610 # AZIMUTH
611 611 self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif]
612 612 self.res_azi[0:comp] = data_azi[dif:]
613 613 # RADAR
614 614 self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:]
615 615 self.res_weather[0:comp,:] = data_weather[dif:,:]
616 616 flag=0
617 617 data_azi = self.res_azi
618 618 data_weather = self.res_weather
619 619
620 620 return data_weather,data_azi
621 621
622 622 def plot(self):
623 623 #print("--------------------------------------",self.ini,"-----------------------------------")
624 624 #numpy.set_printoptions(suppress=True)
625 625 ####print("times: ",self.data.times)
626 626 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
627 627 #print("times: ",thisDatetime)
628 628 data = self.data[-1]
629 629 ####ALTURA altura_tmp_h
630 630 ###print("Y RANGES",self.data.yrange,len(self.data.yrange))
631 631 ###altura_h = (data['weather'].shape[1])/10.0
632 632 ###stoprange = float(altura_h*0.3)#stoprange = float(33*1.5) por ahora 400
633 633 ###rangestep = float(0.03)
634 634 ###r = numpy.arange(0, stoprange, rangestep)
635 635 ###print("r",r,len(r))
636 636 #-----------------------------update----------------------
637 637 r= self.data.yrange
638 638 delta_height = r[1]-r[0]
639 639 #print("1",r)
640 640 r_mask= numpy.where(r>=0)[0]
641 641 r = numpy.arange(len(r_mask))*delta_height
642 642 #print("2",r)
643 643 self.y = 2*r
644 644 ######self.y = self.data.yrange
645 645 # RADAR
646 646 #data_weather = data['weather']
647 647 # PEDESTAL
648 648 #data_azi = data['azi']
649 649 res = 1
650 650 # STEP
651 651 step = (360/(res*data['weather'].shape[0]))
652 652 #print("shape wr_data", wr_data.shape)
653 653 #print("shape wr_azi",wr_azi.shape)
654 654 #print("step",step)
655 655 ####print("Time---->",self.data.times[-1],thisDatetime)
656 656 #print("alturas", len(self.y))numpy.where(r>=0)
657 657 self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res)
658 658 #numpy.set_printoptions(suppress=True)
659 659 #print("resultado",self.res_azi)
660 660 ###########################/DATA_RM/10_tmp/ch0###############################
661 661 ################# PLOTEO ###################
662 662 ##########################################################
663 663
664 664 for i,ax in enumerate(self.axes):
665 665 if ax.firsttime:
666 666 plt.clf()
667 667 cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=8, vmax=35)
668 668 else:
669 669 plt.clf()
670 670 cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=8, vmax=35)
671 671 caax = cgax.parasites[0]
672 672 paax = cgax.parasites[1]
673 673 cbar = plt.gcf().colorbar(pm, pad=0.075)
674 674 caax.set_xlabel('x_range [km]')
675 675 caax.set_ylabel('y_range [km]')
676 676 plt.text(1.0, 1.05, 'azimuth '+str(thisDatetime)+" step "+str(self.ini), transform=caax.transAxes, va='bottom',ha='right')
677 677
678 678 self.ini= self.ini+1
Show file before | Show file after | Hide comments
@@ -1,4608 +1,4318
1 1 import numpy,os,h5py
2 2 import math
3 3 from scipy import optimize, interpolate, signal, stats, ndimage
4 4 import scipy
5 5 import re
6 6 import datetime
7 7 import copy
8 8 import sys
9 9 import importlib
10 10 import itertools
11 11 from multiprocessing import Pool, TimeoutError
12 12 from multiprocessing.pool import ThreadPool
13 13 import time
14 14
15 15 from scipy.optimize import fmin_l_bfgs_b #optimize with bounds on state papameters
16 16 from .jroproc_base import ProcessingUnit, Operation, MPDecorator
17 17 from schainpy.model.data.jrodata import Parameters, hildebrand_sekhon
18 18 from scipy import asarray as ar,exp
19 19 from scipy.optimize import curve_fit
20 20 from schainpy.utils import log
21 21 import warnings
22 22 from numpy import NaN
23 23 from scipy.optimize.optimize import OptimizeWarning
24 24 warnings.filterwarnings('ignore')
25 25
26 26 from time import sleep
27 27
28 28 import matplotlib.pyplot as plt
29 29
30 30 SPEED_OF_LIGHT = 299792458
31 31
32 32 '''solving pickling issue'''
33 33
34 34 def _pickle_method(method):
35 35 func_name = method.__func__.__name__
36 36 obj = method.__self__
37 37 cls = method.__self__.__class__
38 38 return _unpickle_method, (func_name, obj, cls)
39 39
40 40 def _unpickle_method(func_name, obj, cls):
41 41 for cls in cls.mro():
42 42 try:
43 43 func = cls.__dict__[func_name]
44 44 except KeyError:
45 45 pass
46 46 else:
47 47 break
48 48 return func.__get__(obj, cls)
49 49
50 50 def isNumber(str):
51 51 try:
52 52 float(str)
53 53 return True
54 54 except:
55 55 return False
56 56
57 57 class ParametersProc(ProcessingUnit):
58 58
59 59 METHODS = {}
60 60 nSeconds = None
61 61
62 62 def __init__(self):
63 63 ProcessingUnit.__init__(self)
64 64
65 65 # self.objectDict = {}
66 66 self.buffer = None
67 67 self.firstdatatime = None
68 68 self.profIndex = 0
69 69 self.dataOut = Parameters()
70 70 self.setupReq = False #Agregar a todas las unidades de proc
71 71
72 72 def __updateObjFromInput(self):
73 73
74 74 self.dataOut.inputUnit = self.dataIn.type
75 75
76 76 self.dataOut.timeZone = self.dataIn.timeZone
77 77 self.dataOut.dstFlag = self.dataIn.dstFlag
78 78 self.dataOut.errorCount = self.dataIn.errorCount
79 79 self.dataOut.useLocalTime = self.dataIn.useLocalTime
80 80
81 81 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
82 82 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
83 83 self.dataOut.channelList = self.dataIn.channelList
84 84 self.dataOut.heightList = self.dataIn.heightList
85 85 self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
86 86 # self.dataOut.nHeights = self.dataIn.nHeights
87 87 # self.dataOut.nChannels = self.dataIn.nChannels
88 88 # self.dataOut.nBaud = self.dataIn.nBaud
89 89 # self.dataOut.nCode = self.dataIn.nCode
90 90 # self.dataOut.code = self.dataIn.code
91 91 # self.dataOut.nProfiles = self.dataOut.nFFTPoints
92 92 self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
93 93 # self.dataOut.utctime = self.firstdatatime
94 94 self.dataOut.utctime = self.dataIn.utctime
95 95 self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
96 96 self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
97 97 self.dataOut.nCohInt = self.dataIn.nCohInt
98 98 # self.dataOut.nIncohInt = 1
99 99 # self.dataOut.ippSeconds = self.dataIn.ippSeconds
100 100 # self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
101 101 self.dataOut.timeInterval1 = self.dataIn.timeInterval
102 102 self.dataOut.heightList = self.dataIn.heightList
103 103 self.dataOut.frequency = self.dataIn.frequency
104 104 # self.dataOut.noise = self.dataIn.noise
105 105
106 106 def run(self):
107 107
108 108
109 109 #print("HOLA MUNDO SOY YO")
110 110 #---------------------- Voltage Data ---------------------------
111 111
112 112 if self.dataIn.type == "Voltage":
113 113
114 114 self.__updateObjFromInput()
115 115 self.dataOut.data_pre = self.dataIn.data.copy()
116 116 self.dataOut.flagNoData = False
117 117 self.dataOut.utctimeInit = self.dataIn.utctime
118 118 self.dataOut.paramInterval = self.dataIn.nProfiles*self.dataIn.nCohInt*self.dataIn.ippSeconds
119 119
120 120 if hasattr(self.dataIn, 'flagDataAsBlock'):
121 121 self.dataOut.flagDataAsBlock = self.dataIn.flagDataAsBlock
122 122
123 123 if hasattr(self.dataIn, 'profileIndex'):
124 124 self.dataOut.profileIndex = self.dataIn.profileIndex
125 125
126 126 if hasattr(self.dataIn, 'dataPP_POW'):
127 127 self.dataOut.dataPP_POW = self.dataIn.dataPP_POW
128 128
129 129 if hasattr(self.dataIn, 'dataPP_POWER'):
130 130 self.dataOut.dataPP_POWER = self.dataIn.dataPP_POWER
131 131
132 132 if hasattr(self.dataIn, 'dataPP_DOP'):
133 133 self.dataOut.dataPP_DOP = self.dataIn.dataPP_DOP
134 134
135 135 if hasattr(self.dataIn, 'dataPP_SNR'):
136 136 self.dataOut.dataPP_SNR = self.dataIn.dataPP_SNR
137 137
138 138 if hasattr(self.dataIn, 'dataPP_WIDTH'):
139 139 self.dataOut.dataPP_WIDTH = self.dataIn.dataPP_WIDTH
140 140 return
141 141
142 142 #---------------------- Spectra Data ---------------------------
143 143
144 144 if self.dataIn.type == "Spectra":
145 145 #print("que paso en spectra")
146 146 self.dataOut.data_pre = [self.dataIn.data_spc, self.dataIn.data_cspc]
147 147 self.dataOut.data_spc = self.dataIn.data_spc
148 148 self.dataOut.data_cspc = self.dataIn.data_cspc
149 149 self.dataOut.nProfiles = self.dataIn.nProfiles
150 150 self.dataOut.nIncohInt = self.dataIn.nIncohInt
151 151 self.dataOut.nFFTPoints = self.dataIn.nFFTPoints
152 152 self.dataOut.ippFactor = self.dataIn.ippFactor
153 153 self.dataOut.abscissaList = self.dataIn.getVelRange(1)
154 154 self.dataOut.spc_noise = self.dataIn.getNoise()
155 155 self.dataOut.spc_range = (self.dataIn.getFreqRange(1) , self.dataIn.getAcfRange(1) , self.dataIn.getVelRange(1))
156 156 # self.dataOut.normFactor = self.dataIn.normFactor
157 157 self.dataOut.pairsList = self.dataIn.pairsList
158 158 self.dataOut.groupList = self.dataIn.pairsList
159 159 self.dataOut.flagNoData = False
160 160
161 161 if hasattr(self.dataIn, 'flagDataAsBlock'):
162 162 self.dataOut.flagDataAsBlock = self.dataIn.flagDataAsBlock
163 163
164 164 if hasattr(self.dataIn, 'ChanDist'): #Distances of receiver channels
165 165 self.dataOut.ChanDist = self.dataIn.ChanDist
166 166 else: self.dataOut.ChanDist = None
167 167
168 168 #if hasattr(self.dataIn, 'VelRange'): #Velocities range
169 169 # self.dataOut.VelRange = self.dataIn.VelRange
170 170 #else: self.dataOut.VelRange = None
171 171
172 172 if hasattr(self.dataIn, 'RadarConst'): #Radar Constant
173 173 self.dataOut.RadarConst = self.dataIn.RadarConst
174 174
175 175 if hasattr(self.dataIn, 'NPW'): #NPW
176 176 self.dataOut.NPW = self.dataIn.NPW
177 177
178 178 if hasattr(self.dataIn, 'COFA'): #COFA
179 179 self.dataOut.COFA = self.dataIn.COFA
180 180
181 181
182 182
183 183 #---------------------- Correlation Data ---------------------------
184 184
185 185 if self.dataIn.type == "Correlation":
186 186 acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.dataIn.splitFunctions()
187 187
188 188 self.dataOut.data_pre = (self.dataIn.data_cf[acf_ind,:], self.dataIn.data_cf[ccf_ind,:,:])
189 189 self.dataOut.normFactor = (self.dataIn.normFactor[acf_ind,:], self.dataIn.normFactor[ccf_ind,:])
190 190 self.dataOut.groupList = (acf_pairs, ccf_pairs)
191 191
192 192 self.dataOut.abscissaList = self.dataIn.lagRange
193 193 self.dataOut.noise = self.dataIn.noise
194 194 self.dataOut.data_snr = self.dataIn.SNR
195 195 self.dataOut.flagNoData = False
196 196 self.dataOut.nAvg = self.dataIn.nAvg
197 197
198 198 #---------------------- Parameters Data ---------------------------
199 199
200 200 if self.dataIn.type == "Parameters":
201 201 self.dataOut.copy(self.dataIn)
202 202 self.dataOut.flagNoData = False
203 203 #print("yo si entre")
204 204
205 205 return True
206 206
207 207 self.__updateObjFromInput()
208 208 #print("yo si entre2")
209 209
210 210 self.dataOut.utctimeInit = self.dataIn.utctime
211 211 self.dataOut.paramInterval = self.dataIn.timeInterval
212 212 #print("soy spectra ",self.dataOut.utctimeInit)
213 213 return
214 214
215 215
216 216 def target(tups):
217 217
218 218 obj, args = tups
219 219
220 220 return obj.FitGau(args)
221 221
222 222 class RemoveWideGC(Operation):
223 223 ''' This class remove the wide clutter and replace it with a simple interpolation points
224 224 This mainly applies to CLAIRE radar
225 225
226 226 ClutterWidth : Width to look for the clutter peak
227 227
228 228 Input:
229 229
230 230 self.dataOut.data_pre : SPC and CSPC
231 231 self.dataOut.spc_range : To select wind and rainfall velocities
232 232
233 233 Affected:
234 234
235 235 self.dataOut.data_pre : It is used for the new SPC and CSPC ranges of wind
236 236
237 237 Written by D. ScipiΓ³n 25.02.2021
238 238 '''
239 239 def __init__(self):
240 240 Operation.__init__(self)
241 241 self.i = 0
242 242 self.ich = 0
243 243 self.ir = 0
244 244
245 245 def run(self, dataOut, ClutterWidth=2.5):
246 246 # print ('Entering RemoveWideGC ... ')
247 247
248 248 self.spc = dataOut.data_pre[0].copy()
249 249 self.spc_out = dataOut.data_pre[0].copy()
250 250 self.Num_Chn = self.spc.shape[0]
251 251 self.Num_Hei = self.spc.shape[2]
252 252 VelRange = dataOut.spc_range[2][:-1]
253 253 dv = VelRange[1]-VelRange[0]
254 254
255 255 # Find the velocities that corresponds to zero
256 256 gc_values = numpy.squeeze(numpy.where(numpy.abs(VelRange) <= ClutterWidth))
257 257
258 258 # Removing novalid data from the spectra
259 259 for ich in range(self.Num_Chn) :
260 260 for ir in range(self.Num_Hei) :
261 261 # Estimate the noise at each range
262 262 HSn = hildebrand_sekhon(self.spc[ich,:,ir],dataOut.nIncohInt)
263 263
264 264 # Removing the noise floor at each range
265 265 novalid = numpy.where(self.spc[ich,:,ir] < HSn)
266 266 self.spc[ich,novalid,ir] = HSn
267 267
268 268 junk = numpy.append(numpy.insert(numpy.squeeze(self.spc[ich,gc_values,ir]),0,HSn),HSn)
269 269 j1index = numpy.squeeze(numpy.where(numpy.diff(junk)>0))
270 270 j2index = numpy.squeeze(numpy.where(numpy.diff(junk)<0))
271 271 if ((numpy.size(j1index)<=1) | (numpy.size(j2index)<=1)) :
272 272 continue
273 273 junk3 = numpy.squeeze(numpy.diff(j1index))
274 274 junk4 = numpy.squeeze(numpy.diff(j2index))
275 275
276 276 valleyindex = j2index[numpy.where(junk4>1)]
277 277 peakindex = j1index[numpy.where(junk3>1)]
278 278
279 279 isvalid = numpy.squeeze(numpy.where(numpy.abs(VelRange[gc_values[peakindex]]) <= 2.5*dv))
280 280 if numpy.size(isvalid) == 0 :
281 281 continue
282 282 if numpy.size(isvalid) >1 :
283 283 vindex = numpy.argmax(self.spc[ich,gc_values[peakindex[isvalid]],ir])
284 284 isvalid = isvalid[vindex]
285 285
286 286 # clutter peak
287 287 gcpeak = peakindex[isvalid]
288 288 vl = numpy.where(valleyindex < gcpeak)
289 289 if numpy.size(vl) == 0:
290 290 continue
291 291 gcvl = valleyindex[vl[0][-1]]
292 292 vr = numpy.where(valleyindex > gcpeak)
293 293 if numpy.size(vr) == 0:
294 294 continue
295 295 gcvr = valleyindex[vr[0][0]]
296 296
297 297 # Removing the clutter
298 298 interpindex = numpy.array([gc_values[gcvl], gc_values[gcvr]])
299 299 gcindex = gc_values[gcvl+1:gcvr-1]
300 300 self.spc_out[ich,gcindex,ir] = numpy.interp(VelRange[gcindex],VelRange[interpindex],self.spc[ich,interpindex,ir])
301 301
302 302 dataOut.data_pre[0] = self.spc_out
303 303 #print ('Leaving RemoveWideGC ... ')
304 304 return dataOut
305 305
306 306 class SpectralFilters(Operation):
307 307 ''' This class allows to replace the novalid values with noise for each channel
308 308 This applies to CLAIRE RADAR
309 309
310 310 PositiveLimit : RightLimit of novalid data
311 311 NegativeLimit : LeftLimit of novalid data
312 312
313 313 Input:
314 314
315 315 self.dataOut.data_pre : SPC and CSPC
316 316 self.dataOut.spc_range : To select wind and rainfall velocities
317 317
318 318 Affected:
319 319
320 320 self.dataOut.data_pre : It is used for the new SPC and CSPC ranges of wind
321 321
322 322 Written by D. ScipiΓ³n 29.01.2021
323 323 '''
324 324 def __init__(self):
325 325 Operation.__init__(self)
326 326 self.i = 0
327 327
328 328 def run(self, dataOut, ):
329 329
330 330 self.spc = dataOut.data_pre[0].copy()
331 331 self.Num_Chn = self.spc.shape[0]
332 332 VelRange = dataOut.spc_range[2]
333 333
334 334 # novalid corresponds to data within the Negative and PositiveLimit
335 335
336 336
337 337 # Removing novalid data from the spectra
338 338 for i in range(self.Num_Chn):
339 339 self.spc[i,novalid,:] = dataOut.noise[i]
340 340 dataOut.data_pre[0] = self.spc
341 341 return dataOut
342 342
343 343 class GaussianFit(Operation):
344 344
345 345 '''
346 346 Function that fit of one and two generalized gaussians (gg) based
347 347 on the PSD shape across an "power band" identified from a cumsum of
348 348 the measured spectrum - noise.
349 349
350 350 Input:
351 351 self.dataOut.data_pre : SelfSpectra
352 352
353 353 Output:
354 354 self.dataOut.SPCparam : SPC_ch1, SPC_ch2
355 355
356 356 '''
357 357 def __init__(self):
358 358 Operation.__init__(self)
359 359 self.i=0
360 360
361 361
362 362 # def run(self, dataOut, num_intg=7, pnoise=1., SNRlimit=-9): #num_intg: Incoherent integrations, pnoise: Noise, vel_arr: range of velocities, similar to the ftt points
363 363 def run(self, dataOut, SNRdBlimit=-9, method='generalized'):
364 364 """This routine will find a couple of generalized Gaussians to a power spectrum
365 365 methods: generalized, squared
366 366 input: spc
367 367 output:
368 368 noise, amplitude0,shift0,width0,p0,Amplitude1,shift1,width1,p1
369 369 """
370 370 print ('Entering ',method,' double Gaussian fit')
371 371 self.spc = dataOut.data_pre[0].copy()
372 372 self.Num_Hei = self.spc.shape[2]
373 373 self.Num_Bin = self.spc.shape[1]
374 374 self.Num_Chn = self.spc.shape[0]
375 375
376 376 start_time = time.time()
377 377
378 378 pool = Pool(processes=self.Num_Chn)
379 379 args = [(dataOut.spc_range[2], ich, dataOut.spc_noise[ich], dataOut.nIncohInt, SNRdBlimit) for ich in range(self.Num_Chn)]
380 380 objs = [self for __ in range(self.Num_Chn)]
381 381 attrs = list(zip(objs, args))
382 382 DGauFitParam = pool.map(target, attrs)
383 383 # Parameters:
384 384 # 0. Noise, 1. Amplitude, 2. Shift, 3. Width 4. Power
385 385 dataOut.DGauFitParams = numpy.asarray(DGauFitParam)
386 386
387 387 # Double Gaussian Curves
388 388 gau0 = numpy.zeros([self.Num_Chn,self.Num_Bin,self.Num_Hei])
389 389 gau0[:] = numpy.NaN
390 390 gau1 = numpy.zeros([self.Num_Chn,self.Num_Bin,self.Num_Hei])
391 391 gau1[:] = numpy.NaN
392 392 x_mtr = numpy.transpose(numpy.tile(dataOut.getVelRange(1)[:-1], (self.Num_Hei,1)))
393 393 for iCh in range(self.Num_Chn):
394 394 N0 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][0,:,0]] * self.Num_Bin))
395 395 N1 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][0,:,1]] * self.Num_Bin))
396 396 A0 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][1,:,0]] * self.Num_Bin))
397 397 A1 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][1,:,1]] * self.Num_Bin))
398 398 v0 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][2,:,0]] * self.Num_Bin))
399 399 v1 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][2,:,1]] * self.Num_Bin))
400 400 s0 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][3,:,0]] * self.Num_Bin))
401 401 s1 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][3,:,1]] * self.Num_Bin))
402 402 if method == 'genealized':
403 403 p0 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][4,:,0]] * self.Num_Bin))
404 404 p1 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][4,:,1]] * self.Num_Bin))
405 405 elif method == 'squared':
406 406 p0 = 2.
407 407 p1 = 2.
408 408 gau0[iCh] = A0*numpy.exp(-0.5*numpy.abs((x_mtr-v0)/s0)**p0)+N0
409 409 gau1[iCh] = A1*numpy.exp(-0.5*numpy.abs((x_mtr-v1)/s1)**p1)+N1
410 410 dataOut.GaussFit0 = gau0
411 411 dataOut.GaussFit1 = gau1
412 412
413 413 print('Leaving ',method ,' double Gaussian fit')
414 414 return dataOut
415 415
416 416 def FitGau(self, X):
417 417 # print('Entering FitGau')
418 418 # Assigning the variables
419 419 Vrange, ch, wnoise, num_intg, SNRlimit = X
420 420 # Noise Limits
421 421 noisebl = wnoise * 0.9
422 422 noisebh = wnoise * 1.1
423 423 # Radar Velocity
424 424 Va = max(Vrange)
425 425 deltav = Vrange[1] - Vrange[0]
426 426 x = numpy.arange(self.Num_Bin)
427 427
428 428 # print ('stop 0')
429 429
430 430 # 5 parameters, 2 Gaussians
431 431 DGauFitParam = numpy.zeros([5, self.Num_Hei,2])
432 432 DGauFitParam[:] = numpy.NaN
433 433
434 434 # SPCparam = []
435 435 # SPC_ch1 = numpy.zeros([self.Num_Bin,self.Num_Hei])
436 436 # SPC_ch2 = numpy.zeros([self.Num_Bin,self.Num_Hei])
437 437 # SPC_ch1[:] = 0 #numpy.NaN
438 438 # SPC_ch2[:] = 0 #numpy.NaN
439 439 # print ('stop 1')
440 440 for ht in range(self.Num_Hei):
441 441 # print (ht)
442 442 # print ('stop 2')
443 443 # Spectra at each range
444 444 spc = numpy.asarray(self.spc)[ch,:,ht]
445 445 snr = ( spc.mean() - wnoise ) / wnoise
446 446 snrdB = 10.*numpy.log10(snr)
447 447
448 448 #print ('stop 3')
449 449 if snrdB < SNRlimit :
450 450 # snr = numpy.NaN
451 451 # SPC_ch1[:,ht] = 0#numpy.NaN
452 452 # SPC_ch1[:,ht] = 0#numpy.NaN
453 453 # SPCparam = (SPC_ch1,SPC_ch2)
454 454 # print ('SNR less than SNRth')
455 455 continue
456 456 # wnoise = hildebrand_sekhon(spc,num_intg)
457 457 # print ('stop 2.01')
458 458 #############################################
459 459 # normalizing spc and noise
460 460 # This part differs from gg1
461 461 # spc_norm_max = max(spc) #commented by D. ScipiΓ³n 19.03.2021
462 462 #spc = spc / spc_norm_max
463 463 # pnoise = pnoise #/ spc_norm_max #commented by D. ScipiΓ³n 19.03.2021
464 464 #############################################
465 465
466 466 # print ('stop 2.1')
467 467 fatspectra=1.0
468 468 # noise per channel.... we might want to use the noise at each range
469 469
470 470 # wnoise = noise_ #/ spc_norm_max #commented by D. ScipiΓ³n 19.03.2021
471 471 #wnoise,stdv,i_max,index =enoise(spc,num_intg) #noise estimate using Hildebrand Sekhon, only wnoise is used
472 472 #if wnoise>1.1*pnoise: # to be tested later
473 473 # wnoise=pnoise
474 474 # noisebl = wnoise*0.9
475 475 # noisebh = wnoise*1.1
476 476 spc = spc - wnoise # signal
477 477
478 478 # print ('stop 2.2')
479 479 minx = numpy.argmin(spc)
480 480 #spcs=spc.copy()
481 481 spcs = numpy.roll(spc,-minx)
482 482 cum = numpy.cumsum(spcs)
483 483 # tot_noise = wnoise * self.Num_Bin #64;
484 484
485 485 # print ('stop 2.3')
486 486 # snr = sum(spcs) / tot_noise
487 487 # snrdB = 10.*numpy.log10(snr)
488 488 #print ('stop 3')
489 489 # if snrdB < SNRlimit :
490 490 # snr = numpy.NaN
491 491 # SPC_ch1[:,ht] = 0#numpy.NaN
492 492 # SPC_ch1[:,ht] = 0#numpy.NaN
493 493 # SPCparam = (SPC_ch1,SPC_ch2)
494 494 # print ('SNR less than SNRth')
495 495 # continue
496 496
497 497
498 498 #if snrdB<-18 or numpy.isnan(snrdB) or num_intg<4:
499 499 # return [None,]*4,[None,]*4,None,snrdB,None,None,[None,]*5,[None,]*9,None
500 500 # print ('stop 4')
501 501 cummax = max(cum)
502 502 epsi = 0.08 * fatspectra # cumsum to narrow down the energy region
503 503 cumlo = cummax * epsi
504 504 cumhi = cummax * (1-epsi)
505 505 powerindex = numpy.array(numpy.where(numpy.logical_and(cum>cumlo, cum<cumhi))[0])
506 506
507 507 # print ('stop 5')
508 508 if len(powerindex) < 1:# case for powerindex 0
509 509 # print ('powerindex < 1')
510 510 continue
511 511 powerlo = powerindex[0]
512 512 powerhi = powerindex[-1]
513 513 powerwidth = powerhi-powerlo
514 514 if powerwidth <= 1:
515 515 # print('powerwidth <= 1')
516 516 continue
517 517
518 518 # print ('stop 6')
519 519 firstpeak = powerlo + powerwidth/10.# first gaussian energy location
520 520 secondpeak = powerhi - powerwidth/10. #second gaussian energy location
521 521 midpeak = (firstpeak + secondpeak)/2.
522 522 firstamp = spcs[int(firstpeak)]
523 523 secondamp = spcs[int(secondpeak)]
524 524 midamp = spcs[int(midpeak)]
525 525
526 526 y_data = spc + wnoise
527 527
528 528 ''' single Gaussian '''
529 529 shift0 = numpy.mod(midpeak+minx, self.Num_Bin )
530 530 width0 = powerwidth/4.#Initialization entire power of spectrum divided by 4
531 531 power0 = 2.
532 532 amplitude0 = midamp
533 533 state0 = [shift0,width0,amplitude0,power0,wnoise]
534 534 bnds = ((0,self.Num_Bin-1),(1,powerwidth),(0,None),(0.5,3.),(noisebl,noisebh))
535 535 lsq1 = fmin_l_bfgs_b(self.misfit1, state0, args=(y_data,x,num_intg), bounds=bnds, approx_grad=True)
536 536 # print ('stop 7.1')
537 537 # print (bnds)
538 538
539 539 chiSq1=lsq1[1]
540 540
541 541 # print ('stop 8')
542 542 if fatspectra<1.0 and powerwidth<4:
543 543 choice=0
544 544 Amplitude0=lsq1[0][2]
545 545 shift0=lsq1[0][0]
546 546 width0=lsq1[0][1]
547 547 p0=lsq1[0][3]
548 548 Amplitude1=0.
549 549 shift1=0.
550 550 width1=0.
551 551 p1=0.
552 552 noise=lsq1[0][4]
553 553 #return (numpy.array([shift0,width0,Amplitude0,p0]),
554 554 # numpy.array([shift1,width1,Amplitude1,p1]),noise,snrdB,chiSq1,6.,sigmas1,[None,]*9,choice)
555 555
556 556 # print ('stop 9')
557 557 ''' two Gaussians '''
558 558 #shift0=numpy.mod(firstpeak+minx,64); shift1=numpy.mod(secondpeak+minx,64)
559 559 shift0 = numpy.mod(firstpeak+minx, self.Num_Bin )
560 560 shift1 = numpy.mod(secondpeak+minx, self.Num_Bin )
561 561 width0 = powerwidth/6.
562 562 width1 = width0
563 563 power0 = 2.
564 564 power1 = power0
565 565 amplitude0 = firstamp
566 566 amplitude1 = secondamp
567 567 state0 = [shift0,width0,amplitude0,power0,shift1,width1,amplitude1,power1,wnoise]
568 568 #bnds=((0,63),(1,powerwidth/2.),(0,None),(0.5,3.),(0,63),(1,powerwidth/2.),(0,None),(0.5,3.),(noisebl,noisebh))
569 569 bnds=((0,self.Num_Bin-1),(1,powerwidth/2.),(0,None),(0.5,3.),(0,self.Num_Bin-1),(1,powerwidth/2.),(0,None),(0.5,3.),(noisebl,noisebh))
570 570 #bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth/2.),(0,None),(0.5,3.),( 0,(self.Num_Bin-1)),(1,powerwidth/2.),(0,None),(0.5,3.),(0.1,0.5))
571 571
572 572 # print ('stop 10')
573 573 lsq2 = fmin_l_bfgs_b( self.misfit2 , state0 , args=(y_data,x,num_intg) , bounds=bnds , approx_grad=True )
574 574
575 575 # print ('stop 11')
576 576 chiSq2 = lsq2[1]
577 577
578 578 # print ('stop 12')
579 579
580 580 oneG = (chiSq1<5 and chiSq1/chiSq2<2.0) and (abs(lsq2[0][0]-lsq2[0][4])<(lsq2[0][1]+lsq2[0][5])/3. or abs(lsq2[0][0]-lsq2[0][4])<10)
581 581
582 582 # print ('stop 13')
583 583 if snrdB>-12: # when SNR is strong pick the peak with least shift (LOS velocity) error
584 584 if oneG:
585 585 choice = 0
586 586 else:
587 587 w1 = lsq2[0][1]; w2 = lsq2[0][5]
588 588 a1 = lsq2[0][2]; a2 = lsq2[0][6]
589 589 p1 = lsq2[0][3]; p2 = lsq2[0][7]
590 590 s1 = (2**(1+1./p1))*scipy.special.gamma(1./p1)/p1
591 591 s2 = (2**(1+1./p2))*scipy.special.gamma(1./p2)/p2
592 592 gp1 = a1*w1*s1; gp2 = a2*w2*s2 # power content of each ggaussian with proper p scaling
593 593
594 594 if gp1>gp2:
595 595 if a1>0.7*a2:
596 596 choice = 1
597 597 else:
598 598 choice = 2
599 599 elif gp2>gp1:
600 600 if a2>0.7*a1:
601 601 choice = 2
602 602 else:
603 603 choice = 1
604 604 else:
605 605 choice = numpy.argmax([a1,a2])+1
606 606 #else:
607 607 #choice=argmin([std2a,std2b])+1
608 608
609 609 else: # with low SNR go to the most energetic peak
610 610 choice = numpy.argmax([lsq1[0][2]*lsq1[0][1],lsq2[0][2]*lsq2[0][1],lsq2[0][6]*lsq2[0][5]])
611 611
612 612 # print ('stop 14')
613 613 shift0 = lsq2[0][0]
614 614 vel0 = Vrange[0] + shift0 * deltav
615 615 shift1 = lsq2[0][4]
616 616 # vel1=Vrange[0] + shift1 * deltav
617 617
618 618 # max_vel = 1.0
619 619 # Va = max(Vrange)
620 620 # deltav = Vrange[1]-Vrange[0]
621 621 # print ('stop 15')
622 622 #first peak will be 0, second peak will be 1
623 623 # if vel0 > -1.0 and vel0 < max_vel : #first peak is in the correct range # Commented by D.ScipiΓ³n 19.03.2021
624 624 if vel0 > -Va and vel0 < Va : #first peak is in the correct range
625 625 shift0 = lsq2[0][0]
626 626 width0 = lsq2[0][1]
627 627 Amplitude0 = lsq2[0][2]
628 628 p0 = lsq2[0][3]
629 629
630 630 shift1 = lsq2[0][4]
631 631 width1 = lsq2[0][5]
632 632 Amplitude1 = lsq2[0][6]
633 633 p1 = lsq2[0][7]
634 634 noise = lsq2[0][8]
635 635 else:
636 636 shift1 = lsq2[0][0]
637 637 width1 = lsq2[0][1]
638 638 Amplitude1 = lsq2[0][2]
639 639 p1 = lsq2[0][3]
640 640
641 641 shift0 = lsq2[0][4]
642 642 width0 = lsq2[0][5]
643 643 Amplitude0 = lsq2[0][6]
644 644 p0 = lsq2[0][7]
645 645 noise = lsq2[0][8]
646 646
647 647 if Amplitude0<0.05: # in case the peak is noise
648 648 shift0,width0,Amplitude0,p0 = 4*[numpy.NaN]
649 649 if Amplitude1<0.05:
650 650 shift1,width1,Amplitude1,p1 = 4*[numpy.NaN]
651 651
652 652 # print ('stop 16 ')
653 653 # SPC_ch1[:,ht] = noise + Amplitude0*numpy.exp(-0.5*(abs(x-shift0)/width0)**p0)
654 654 # SPC_ch2[:,ht] = noise + Amplitude1*numpy.exp(-0.5*(abs(x-shift1)/width1)**p1)
655 655 # SPCparam = (SPC_ch1,SPC_ch2)
656 656
657 657 DGauFitParam[0,ht,0] = noise
658 658 DGauFitParam[0,ht,1] = noise
659 659 DGauFitParam[1,ht,0] = Amplitude0
660 660 DGauFitParam[1,ht,1] = Amplitude1
661 661 DGauFitParam[2,ht,0] = Vrange[0] + shift0 * deltav
662 662 DGauFitParam[2,ht,1] = Vrange[0] + shift1 * deltav
663 663 DGauFitParam[3,ht,0] = width0 * deltav
664 664 DGauFitParam[3,ht,1] = width1 * deltav
665 665 DGauFitParam[4,ht,0] = p0
666 666 DGauFitParam[4,ht,1] = p1
667 667
668 668 # print (DGauFitParam.shape)
669 669 # print ('Leaving FitGau')
670 670 return DGauFitParam
671 671 # return SPCparam
672 672 # return GauSPC
673 673
674 674 def y_model1(self,x,state):
675 675 shift0, width0, amplitude0, power0, noise = state
676 676 model0 = amplitude0*numpy.exp(-0.5*abs((x - shift0)/width0)**power0)
677 677 model0u = amplitude0*numpy.exp(-0.5*abs((x - shift0 - self.Num_Bin)/width0)**power0)
678 678 model0d = amplitude0*numpy.exp(-0.5*abs((x - shift0 + self.Num_Bin)/width0)**power0)
679 679 return model0 + model0u + model0d + noise
680 680
681 681 def y_model2(self,x,state): #Equation for two generalized Gaussians with Nyquist
682 682 shift0, width0, amplitude0, power0, shift1, width1, amplitude1, power1, noise = state
683 683 model0 = amplitude0*numpy.exp(-0.5*abs((x-shift0)/width0)**power0)
684 684 model0u = amplitude0*numpy.exp(-0.5*abs((x - shift0 - self.Num_Bin)/width0)**power0)
685 685 model0d = amplitude0*numpy.exp(-0.5*abs((x - shift0 + self.Num_Bin)/width0)**power0)
686 686
687 687 model1 = amplitude1*numpy.exp(-0.5*abs((x - shift1)/width1)**power1)
688 688 model1u = amplitude1*numpy.exp(-0.5*abs((x - shift1 - self.Num_Bin)/width1)**power1)
689 689 model1d = amplitude1*numpy.exp(-0.5*abs((x - shift1 + self.Num_Bin)/width1)**power1)
690 690 return model0 + model0u + model0d + model1 + model1u + model1d + noise
691 691
692 692 def misfit1(self,state,y_data,x,num_intg): # This function compares how close real data is with the model data, the close it is, the better it is.
693 693
694 694 return num_intg*sum((numpy.log(y_data)-numpy.log(self.y_model1(x,state)))**2)#/(64-5.) # /(64-5.) can be commented
695 695
696 696 def misfit2(self,state,y_data,x,num_intg):
697 697 return num_intg*sum((numpy.log(y_data)-numpy.log(self.y_model2(x,state)))**2)#/(64-9.)
698 698
699 699
700 700
701 701 class PrecipitationProc(Operation):
702 702
703 703 '''
704 704 Operator that estimates Reflectivity factor (Z), and estimates rainfall Rate (R)
705 705
706 706 Input:
707 707 self.dataOut.data_pre : SelfSpectra
708 708
709 709 Output:
710 710
711 711 self.dataOut.data_output : Reflectivity factor, rainfall Rate
712 712
713 713
714 714 Parameters affected:
715 715 '''
716 716
717 717 def __init__(self):
718 718 Operation.__init__(self)
719 719 self.i=0
720 720
721 721 def run(self, dataOut, radar=None, Pt=5000, Gt=295.1209, Gr=70.7945, Lambda=0.6741, aL=2.5118,
722 722 tauW=4e-06, ThetaT=0.1656317, ThetaR=0.36774087, Km2 = 0.93, Altitude=3350,SNRdBlimit=-30):
723 723
724 724 # print ('Entering PrecepitationProc ... ')
725 725
726 726 if radar == "MIRA35C" :
727 727
728 728 self.spc = dataOut.data_pre[0].copy()
729 729 self.Num_Hei = self.spc.shape[2]
730 730 self.Num_Bin = self.spc.shape[1]
731 731 self.Num_Chn = self.spc.shape[0]
732 732 Ze = self.dBZeMODE2(dataOut)
733 733
734 734 else:
735 735
736 736 self.spc = dataOut.data_pre[0].copy()
737 737
738 738 #NOTA SE DEBE REMOVER EL RANGO DEL PULSO TX
739 739 self.spc[:,:,0:7]= numpy.NaN
740 740
741 741 self.Num_Hei = self.spc.shape[2]
742 742 self.Num_Bin = self.spc.shape[1]
743 743 self.Num_Chn = self.spc.shape[0]
744 744
745 745 VelRange = dataOut.spc_range[2]
746 746
747 747 ''' Se obtiene la constante del RADAR '''
748 748
749 749 self.Pt = Pt
750 750 self.Gt = Gt
751 751 self.Gr = Gr
752 752 self.Lambda = Lambda
753 753 self.aL = aL
754 754 self.tauW = tauW
755 755 self.ThetaT = ThetaT
756 756 self.ThetaR = ThetaR
757 757 self.GSys = 10**(36.63/10) # Ganancia de los LNA 36.63 dB
758 758 self.lt = 10**(1.67/10) # Perdida en cables Tx 1.67 dB
759 759 self.lr = 10**(5.73/10) # Perdida en cables Rx 5.73 dB
760 760
761 761 Numerator = ( (4*numpy.pi)**3 * aL**2 * 16 * numpy.log(2) )
762 762 Denominator = ( Pt * Gt * Gr * Lambda**2 * SPEED_OF_LIGHT * tauW * numpy.pi * ThetaT * ThetaR)
763 763 RadarConstant = 10e-26 * Numerator / Denominator #
764 764 ExpConstant = 10**(40/10) #Constante Experimental
765 765
766 766 SignalPower = numpy.zeros([self.Num_Chn,self.Num_Bin,self.Num_Hei])
767 767 for i in range(self.Num_Chn):
768 768 SignalPower[i,:,:] = self.spc[i,:,:] - dataOut.noise[i]
769 769 SignalPower[numpy.where(SignalPower < 0)] = 1e-20
770 770
771 771 SPCmean = numpy.mean(SignalPower, 0)
772 772 Pr = SPCmean[:,:]/dataOut.normFactor
773 773
774 774 # Declaring auxiliary variables
775 775 Range = dataOut.heightList*1000. #Range in m
776 776 # replicate the heightlist to obtain a matrix [Num_Bin,Num_Hei]
777 777 rMtrx = numpy.transpose(numpy.transpose([dataOut.heightList*1000.] * self.Num_Bin))
778 778 zMtrx = rMtrx+Altitude
779 779 # replicate the VelRange to obtain a matrix [Num_Bin,Num_Hei]
780 780 VelMtrx = numpy.transpose(numpy.tile(VelRange[:-1], (self.Num_Hei,1)))
781 781
782 782 # height dependence to air density Foote and Du Toit (1969)
783 783 delv_z = 1 + 3.68e-5 * zMtrx + 1.71e-9 * zMtrx**2
784 784 VMtrx = VelMtrx / delv_z #Normalized velocity
785 785 VMtrx[numpy.where(VMtrx> 9.6)] = numpy.NaN
786 786 # Diameter is related to the fall speed of falling drops
787 787 D_Vz = -1.667 * numpy.log( 0.9369 - 0.097087 * VMtrx ) # D in [mm]
788 788 # Only valid for D>= 0.16 mm
789 789 D_Vz[numpy.where(D_Vz < 0.16)] = numpy.NaN
790 790
791 791 #Calculate Radar Reflectivity ETAn
792 792 ETAn = (RadarConstant *ExpConstant) * Pr * rMtrx**2 #Reflectivity (ETA)
793 793 ETAd = ETAn * 6.18 * exp( -0.6 * D_Vz ) * delv_z
794 794 # Radar Cross Section
795 795 sigmaD = Km2 * (D_Vz * 1e-3 )**6 * numpy.pi**5 / Lambda**4
796 796 # Drop Size Distribution
797 797 DSD = ETAn / sigmaD
798 798 # Equivalente Reflectivy
799 799 Ze_eqn = numpy.nansum( DSD * D_Vz**6 ,axis=0)
800 800 Ze_org = numpy.nansum(ETAn * Lambda**4, axis=0) / (1e-18*numpy.pi**5 * Km2) # [mm^6 /m^3]
801 801 # RainFall Rate
802 802 RR = 0.0006*numpy.pi * numpy.nansum( D_Vz**3 * DSD * VelMtrx ,0) #mm/hr
803 803
804 804 # Censoring the data
805 805 # Removing data with SNRth < 0dB se debe considerar el SNR por canal
806 806 SNRth = 10**(SNRdBlimit/10) #-30dB
807 807 novalid = numpy.where((dataOut.data_snr[0,:] <SNRth) | (dataOut.data_snr[1,:] <SNRth) | (dataOut.data_snr[2,:] <SNRth)) # AND condition. Maybe OR condition better
808 808 W = numpy.nanmean(dataOut.data_dop,0)
809 809 W[novalid] = numpy.NaN
810 810 Ze_org[novalid] = numpy.NaN
811 811 RR[novalid] = numpy.NaN
812 812
813 813 dataOut.data_output = RR[8]
814 814 dataOut.data_param = numpy.ones([3,self.Num_Hei])
815 815 dataOut.channelList = [0,1,2]
816 816
817 817 dataOut.data_param[0]=10*numpy.log10(Ze_org)
818 818 dataOut.data_param[1]=-W
819 819 dataOut.data_param[2]=RR
820 820
821 821 # print ('Leaving PrecepitationProc ... ')
822 822 return dataOut
823 823
824 824 def dBZeMODE2(self, dataOut): # Processing for MIRA35C
825 825
826 826 NPW = dataOut.NPW
827 827 COFA = dataOut.COFA
828 828
829 829 SNR = numpy.array([self.spc[0,:,:] / NPW[0]]) #, self.spc[1,:,:] / NPW[1]])
830 830 RadarConst = dataOut.RadarConst
831 831 #frequency = 34.85*10**9
832 832
833 833 ETA = numpy.zeros(([self.Num_Chn ,self.Num_Hei]))
834 834 data_output = numpy.ones([self.Num_Chn , self.Num_Hei])*numpy.NaN
835 835
836 836 ETA = numpy.sum(SNR,1)
837 837
838 838 ETA = numpy.where(ETA != 0. , ETA, numpy.NaN)
839 839
840 840 Ze = numpy.ones([self.Num_Chn, self.Num_Hei] )
841 841
842 842 for r in range(self.Num_Hei):
843 843
844 844 Ze[0,r] = ( ETA[0,r] ) * COFA[0,r][0] * RadarConst * ((r/5000.)**2)
845 845 #Ze[1,r] = ( ETA[1,r] ) * COFA[1,r][0] * RadarConst * ((r/5000.)**2)
846 846
847 847 return Ze
848 848
849 849 # def GetRadarConstant(self):
850 850 #
851 851 # """
852 852 # Constants:
853 853 #
854 854 # Pt: Transmission Power dB 5kW 5000
855 855 # Gt: Transmission Gain dB 24.7 dB 295.1209
856 856 # Gr: Reception Gain dB 18.5 dB 70.7945
857 857 # Lambda: Wavelenght m 0.6741 m 0.6741
858 858 # aL: Attenuation loses dB 4dB 2.5118
859 859 # tauW: Width of transmission pulse s 4us 4e-6
860 860 # ThetaT: Transmission antenna bean angle rad 0.1656317 rad 0.1656317
861 861 # ThetaR: Reception antenna beam angle rad 0.36774087 rad 0.36774087
862 862 #
863 863 # """
864 864 #
865 865 # Numerator = ( (4*numpy.pi)**3 * aL**2 * 16 * numpy.log(2) )
866 866 # Denominator = ( Pt * Gt * Gr * Lambda**2 * SPEED_OF_LIGHT * TauW * numpy.pi * ThetaT * TheraR)
867 867 # RadarConstant = Numerator / Denominator
868 868 #
869 869 # return RadarConstant
870 870
871 871
872 872
873 873 class FullSpectralAnalysis(Operation):
874 874
875 875 """
876 876 Function that implements Full Spectral Analysis technique.
877 877
878 878 Input:
879 879 self.dataOut.data_pre : SelfSpectra and CrossSpectra data
880 880 self.dataOut.groupList : Pairlist of channels
881 881 self.dataOut.ChanDist : Physical distance between receivers
882 882
883 883
884 884 Output:
885 885
886 886 self.dataOut.data_output : Zonal wind, Meridional wind, and Vertical wind
887 887
888 888
889 889 Parameters affected: Winds, height range, SNR
890 890
891 891 """
892 892 def run(self, dataOut, Xi01=None, Xi02=None, Xi12=None, Eta01=None, Eta02=None, Eta12=None, SNRdBlimit=-30,
893 893 minheight=None, maxheight=None, NegativeLimit=None, PositiveLimit=None):
894 894
895 895 spc = dataOut.data_pre[0].copy()
896 896 cspc = dataOut.data_pre[1]
897 897 nHeights = spc.shape[2]
898 898
899 899 # first_height = 0.75 #km (ref: data header 20170822)
900 900 # resolution_height = 0.075 #km
901 901 '''
902 902 finding height range. check this when radar parameters are changed!
903 903 '''
904 904 if maxheight is not None:
905 905 # range_max = math.ceil((maxheight - first_height) / resolution_height) # theoretical
906 906 range_max = math.ceil(13.26 * maxheight - 3) # empirical, works better
907 907 else:
908 908 range_max = nHeights
909 909 if minheight is not None:
910 910 # range_min = int((minheight - first_height) / resolution_height) # theoretical
911 911 range_min = int(13.26 * minheight - 5) # empirical, works better
912 912 if range_min < 0:
913 913 range_min = 0
914 914 else:
915 915 range_min = 0
916 916
917 917 pairsList = dataOut.groupList
918 918 if dataOut.ChanDist is not None :
919 919 ChanDist = dataOut.ChanDist
920 920 else:
921 921 ChanDist = numpy.array([[Xi01, Eta01],[Xi02,Eta02],[Xi12,Eta12]])
922 922
923 923 # 4 variables: zonal, meridional, vertical, and average SNR
924 924 data_param = numpy.zeros([4,nHeights]) * numpy.NaN
925 925 velocityX = numpy.zeros([nHeights]) * numpy.NaN
926 926 velocityY = numpy.zeros([nHeights]) * numpy.NaN
927 927 velocityZ = numpy.zeros([nHeights]) * numpy.NaN
928 928
929 929 dbSNR = 10*numpy.log10(numpy.average(dataOut.data_snr,0))
930 930
931 931 '''***********************************************WIND ESTIMATION**************************************'''
932 932 for Height in range(nHeights):
933 933
934 934 if Height >= range_min and Height < range_max:
935 935 # error_code will be useful in future analysis
936 936 [Vzon,Vmer,Vver, error_code] = self.WindEstimation(spc[:,:,Height], cspc[:,:,Height], pairsList,
937 937 ChanDist, Height, dataOut.noise, dataOut.spc_range, dbSNR[Height], SNRdBlimit, NegativeLimit, PositiveLimit,dataOut.frequency)
938 938
939 939 if abs(Vzon) < 100. and abs(Vmer) < 100.:
940 940 velocityX[Height] = Vzon
941 941 velocityY[Height] = -Vmer
942 942 velocityZ[Height] = Vver
943 943
944 944 # Censoring data with SNR threshold
945 945 dbSNR [dbSNR < SNRdBlimit] = numpy.NaN
946 946
947 947 data_param[0] = velocityX
948 948 data_param[1] = velocityY
949 949 data_param[2] = velocityZ
950 950 data_param[3] = dbSNR
951 951 dataOut.data_param = data_param
952 952 return dataOut
953 953
954 954 def moving_average(self,x, N=2):
955 955 """ convolution for smoothenig data. note that last N-1 values are convolution with zeroes """
956 956 return numpy.convolve(x, numpy.ones((N,))/N)[(N-1):]
957 957
958 958 def gaus(self,xSamples,Amp,Mu,Sigma):
959 959 return Amp * numpy.exp(-0.5*((xSamples - Mu)/Sigma)**2)
960 960
961 961 def Moments(self, ySamples, xSamples):
962 962 Power = numpy.nanmean(ySamples) # Power, 0th Moment
963 963 yNorm = ySamples / numpy.nansum(ySamples)
964 964 RadVel = numpy.nansum(xSamples * yNorm) # Radial Velocity, 1st Moment
965 965 Sigma2 = numpy.nansum(yNorm * (xSamples - RadVel)**2) # Spectral Width, 2nd Moment
966 966 StdDev = numpy.sqrt(numpy.abs(Sigma2)) # Desv. Estandar, Ancho espectral
967 967 return numpy.array([Power,RadVel,StdDev])
968 968
969 969 def StopWindEstimation(self, error_code):
970 970 Vzon = numpy.NaN
971 971 Vmer = numpy.NaN
972 972 Vver = numpy.NaN
973 973 return Vzon, Vmer, Vver, error_code
974 974
975 975 def AntiAliasing(self, interval, maxstep):
976 976 """
977 977 function to prevent errors from aliased values when computing phaseslope
978 978 """
979 979 antialiased = numpy.zeros(len(interval))
980 980 copyinterval = interval.copy()
981 981
982 982 antialiased[0] = copyinterval[0]
983 983
984 984 for i in range(1,len(antialiased)):
985 985 step = interval[i] - interval[i-1]
986 986 if step > maxstep:
987 987 copyinterval -= 2*numpy.pi
988 988 antialiased[i] = copyinterval[i]
989 989 elif step < maxstep*(-1):
990 990 copyinterval += 2*numpy.pi
991 991 antialiased[i] = copyinterval[i]
992 992 else:
993 993 antialiased[i] = copyinterval[i].copy()
994 994
995 995 return antialiased
996 996
997 997 def WindEstimation(self, spc, cspc, pairsList, ChanDist, Height, noise, AbbsisaRange, dbSNR, SNRlimit, NegativeLimit, PositiveLimit, radfreq):
998 998 """
999 999 Function that Calculates Zonal, Meridional and Vertical wind velocities.
1000 1000 Initial Version by E. Bocanegra updated by J. Zibell until Nov. 2019.
1001 1001
1002 1002 Input:
1003 1003 spc, cspc : self spectra and cross spectra data. In Briggs notation something like S_i*(S_i)_conj, (S_j)_conj respectively.
1004 1004 pairsList : Pairlist of channels
1005 1005 ChanDist : array of xi_ij and eta_ij
1006 1006 Height : height at which data is processed
1007 1007 noise : noise in [channels] format for specific height
1008 1008 Abbsisarange : range of the frequencies or velocities
1009 1009 dbSNR, SNRlimit : signal to noise ratio in db, lower limit
1010 1010
1011 1011 Output:
1012 1012 Vzon, Vmer, Vver : wind velocities
1013 1013 error_code : int that states where code is terminated
1014 1014
1015 1015 0 : no error detected
1016 1016 1 : Gaussian of mean spc exceeds widthlimit
1017 1017 2 : no Gaussian of mean spc found
1018 1018 3 : SNR to low or velocity to high -> prec. e.g.
1019 1019 4 : at least one Gaussian of cspc exceeds widthlimit
1020 1020 5 : zero out of three cspc Gaussian fits converged
1021 1021 6 : phase slope fit could not be found
1022 1022 7 : arrays used to fit phase have different length
1023 1023 8 : frequency range is either too short (len <= 5) or very long (> 30% of cspc)
1024 1024
1025 1025 """
1026 1026
1027 1027 error_code = 0
1028 1028
1029 1029 nChan = spc.shape[0]
1030 1030 nProf = spc.shape[1]
1031 1031 nPair = cspc.shape[0]
1032 1032
1033 1033 SPC_Samples = numpy.zeros([nChan, nProf]) # for normalized spc values for one height
1034 1034 CSPC_Samples = numpy.zeros([nPair, nProf], dtype=numpy.complex_) # for normalized cspc values
1035 1035 phase = numpy.zeros([nPair, nProf]) # phase between channels
1036 1036 PhaseSlope = numpy.zeros(nPair) # slope of the phases, channelwise
1037 1037 PhaseInter = numpy.zeros(nPair) # intercept to the slope of the phases, channelwise
1038 1038 xFrec = AbbsisaRange[0][:-1] # frequency range
1039 1039 xVel = AbbsisaRange[2][:-1] # velocity range
1040 1040 xSamples = xFrec # the frequency range is taken
1041 1041 delta_x = xSamples[1] - xSamples[0] # delta_f or delta_x
1042 1042
1043 1043 # only consider velocities with in NegativeLimit and PositiveLimit
1044 1044 if (NegativeLimit is None):
1045 1045 NegativeLimit = numpy.min(xVel)
1046 1046 if (PositiveLimit is None):
1047 1047 PositiveLimit = numpy.max(xVel)
1048 1048 xvalid = numpy.where((xVel > NegativeLimit) & (xVel < PositiveLimit))
1049 1049 xSamples_zoom = xSamples[xvalid]
1050 1050
1051 1051 '''Getting Eij and Nij'''
1052 1052 Xi01, Xi02, Xi12 = ChanDist[:,0]
1053 1053 Eta01, Eta02, Eta12 = ChanDist[:,1]
1054 1054
1055 1055 # spwd limit - updated by D. ScipiΓ³n 30.03.2021
1056 1056 widthlimit = 10
1057 1057 '''************************* SPC is normalized ********************************'''
1058 1058 spc_norm = spc.copy()
1059 1059 # For each channel
1060 1060 for i in range(nChan):
1061 1061 spc_sub = spc_norm[i,:] - noise[i] # only the signal power
1062 1062 SPC_Samples[i] = spc_sub / (numpy.nansum(spc_sub) * delta_x)
1063 1063
1064 1064 '''********************** FITTING MEAN SPC GAUSSIAN **********************'''
1065 1065
1066 1066 """ the gaussian of the mean: first subtract noise, then normalize. this is legal because
1067 1067 you only fit the curve and don't need the absolute value of height for calculation,
1068 1068 only for estimation of width. for normalization of cross spectra, you need initial,
1069 1069 unnormalized self-spectra With noise.
1070 1070
1071 1071 Technically, you don't even need to normalize the self-spectra, as you only need the
1072 1072 width of the peak. However, it was left this way. Note that the normalization has a flaw:
1073 1073 due to subtraction of the noise, some values are below zero. Raw "spc" values should be
1074 1074 >= 0, as it is the modulus squared of the signals (complex * it's conjugate)
1075 1075 """
1076 1076 # initial conditions
1077 1077 popt = [1e-10,0,1e-10]
1078 1078 # Spectra average
1079 1079 SPCMean = numpy.average(SPC_Samples,0)
1080 1080 # Moments in frequency
1081 1081 SPCMoments = self.Moments(SPCMean[xvalid], xSamples_zoom)
1082 1082
1083 1083 # Gauss Fit SPC in frequency domain
1084 1084 if dbSNR > SNRlimit: # only if SNR > SNRth
1085 1085 try:
1086 1086 popt,pcov = curve_fit(self.gaus,xSamples_zoom,SPCMean[xvalid],p0=SPCMoments)
1087 1087 if popt[2] <= 0 or popt[2] > widthlimit: # CONDITION
1088 1088 return self.StopWindEstimation(error_code = 1)
1089 1089 FitGauss = self.gaus(xSamples_zoom,*popt)
1090 1090 except :#RuntimeError:
1091 1091 return self.StopWindEstimation(error_code = 2)
1092 1092 else:
1093 1093 return self.StopWindEstimation(error_code = 3)
1094 1094
1095 1095 '''***************************** CSPC Normalization *************************
1096 1096 The Spc spectra are used to normalize the crossspectra. Peaks from precipitation
1097 1097 influence the norm which is not desired. First, a range is identified where the
1098 1098 wind peak is estimated -> sum_wind is sum of those frequencies. Next, the area
1099 1099 around it gets cut off and values replaced by mean determined by the boundary
1100 1100 data -> sum_noise (spc is not normalized here, thats why the noise is important)
1101 1101
1102 1102 The sums are then added and multiplied by range/datapoints, because you need
1103 1103 an integral and not a sum for normalization.
1104 1104
1105 1105 A norm is found according to Briggs 92.
1106 1106 '''
1107 1107 # for each pair
1108 1108 for i in range(nPair):
1109 1109 cspc_norm = cspc[i,:].copy()
1110 1110 chan_index0 = pairsList[i][0]
1111 1111 chan_index1 = pairsList[i][1]
1112 1112 CSPC_Samples[i] = cspc_norm / (numpy.sqrt(numpy.nansum(spc_norm[chan_index0])*numpy.nansum(spc_norm[chan_index1])) * delta_x)
1113 1113 phase[i] = numpy.arctan2(CSPC_Samples[i].imag, CSPC_Samples[i].real)
1114 1114
1115 1115 CSPCmoments = numpy.vstack([self.Moments(numpy.abs(CSPC_Samples[0,xvalid]), xSamples_zoom),
1116 1116 self.Moments(numpy.abs(CSPC_Samples[1,xvalid]), xSamples_zoom),
1117 1117 self.Moments(numpy.abs(CSPC_Samples[2,xvalid]), xSamples_zoom)])
1118 1118
1119 1119 popt01, popt02, popt12 = [1e-10,0,1e-10], [1e-10,0,1e-10] ,[1e-10,0,1e-10]
1120 1120 FitGauss01, FitGauss02, FitGauss12 = numpy.zeros(len(xSamples)), numpy.zeros(len(xSamples)), numpy.zeros(len(xSamples))
1121 1121
1122 1122 '''*******************************FIT GAUSS CSPC************************************'''
1123 1123 try:
1124 1124 popt01,pcov = curve_fit(self.gaus,xSamples_zoom,numpy.abs(CSPC_Samples[0][xvalid]),p0=CSPCmoments[0])
1125 1125 if popt01[2] > widthlimit: # CONDITION
1126 1126 return self.StopWindEstimation(error_code = 4)
1127 1127 popt02,pcov = curve_fit(self.gaus,xSamples_zoom,numpy.abs(CSPC_Samples[1][xvalid]),p0=CSPCmoments[1])
1128 1128 if popt02[2] > widthlimit: # CONDITION
1129 1129 return self.StopWindEstimation(error_code = 4)
1130 1130 popt12,pcov = curve_fit(self.gaus,xSamples_zoom,numpy.abs(CSPC_Samples[2][xvalid]),p0=CSPCmoments[2])
1131 1131 if popt12[2] > widthlimit: # CONDITION
1132 1132 return self.StopWindEstimation(error_code = 4)
1133 1133
1134 1134 FitGauss01 = self.gaus(xSamples_zoom, *popt01)
1135 1135 FitGauss02 = self.gaus(xSamples_zoom, *popt02)
1136 1136 FitGauss12 = self.gaus(xSamples_zoom, *popt12)
1137 1137 except:
1138 1138 return self.StopWindEstimation(error_code = 5)
1139 1139
1140 1140
1141 1141 '''************* Getting Fij ***************'''
1142 1142 # x-axis point of the gaussian where the center is located from GaussFit of spectra
1143 1143 GaussCenter = popt[1]
1144 1144 ClosestCenter = xSamples_zoom[numpy.abs(xSamples_zoom-GaussCenter).argmin()]
1145 1145 PointGauCenter = numpy.where(xSamples_zoom==ClosestCenter)[0][0]
1146 1146
1147 1147 # Point where e^-1 is located in the gaussian
1148 1148 PeMinus1 = numpy.max(FitGauss) * numpy.exp(-1)
1149 1149 FijClosest = FitGauss[numpy.abs(FitGauss-PeMinus1).argmin()] # The closest point to"Peminus1" in "FitGauss"
1150 1150 PointFij = numpy.where(FitGauss==FijClosest)[0][0]
1151 1151 Fij = numpy.abs(xSamples_zoom[PointFij] - xSamples_zoom[PointGauCenter])
1152 1152
1153 1153 '''********** Taking frequency ranges from mean SPCs **********'''
1154 1154 GauWidth = popt[2] * 3/2 # Bandwidth of Gau01
1155 1155 Range = numpy.empty(2)
1156 1156 Range[0] = GaussCenter - GauWidth
1157 1157 Range[1] = GaussCenter + GauWidth
1158 1158 # Point in x-axis where the bandwidth is located (min:max)
1159 1159 ClosRangeMin = xSamples_zoom[numpy.abs(xSamples_zoom-Range[0]).argmin()]
1160 1160 ClosRangeMax = xSamples_zoom[numpy.abs(xSamples_zoom-Range[1]).argmin()]
1161 1161 PointRangeMin = numpy.where(xSamples_zoom==ClosRangeMin)[0][0]
1162 1162 PointRangeMax = numpy.where(xSamples_zoom==ClosRangeMax)[0][0]
1163 1163 Range = numpy.array([ PointRangeMin, PointRangeMax ])
1164 1164 FrecRange = xSamples_zoom[ Range[0] : Range[1] ]
1165 1165
1166 1166 '''************************** Getting Phase Slope ***************************'''
1167 1167 for i in range(nPair):
1168 1168 if len(FrecRange) > 5:
1169 1169 PhaseRange = phase[i, xvalid[0][Range[0]:Range[1]]].copy()
1170 1170 mask = ~numpy.isnan(FrecRange) & ~numpy.isnan(PhaseRange)
1171 1171 if len(FrecRange) == len(PhaseRange):
1172 1172 try:
1173 1173 slope, intercept, _, _, _ = stats.linregress(FrecRange[mask], self.AntiAliasing(PhaseRange[mask], 4.5))
1174 1174 PhaseSlope[i] = slope
1175 1175 PhaseInter[i] = intercept
1176 1176 except:
1177 1177 return self.StopWindEstimation(error_code = 6)
1178 1178 else:
1179 1179 return self.StopWindEstimation(error_code = 7)
1180 1180 else:
1181 1181 return self.StopWindEstimation(error_code = 8)
1182 1182
1183 1183 '''*** Constants A-H correspond to the convention as in Briggs and Vincent 1992 ***'''
1184 1184
1185 1185 '''Getting constant C'''
1186 1186 cC=(Fij*numpy.pi)**2
1187 1187
1188 1188 '''****** Getting constants F and G ******'''
1189 1189 MijEijNij = numpy.array([[Xi02,Eta02], [Xi12,Eta12]])
1190 1190 # MijEijNij = numpy.array([[Xi01,Eta01], [Xi02,Eta02], [Xi12,Eta12]])
1191 1191 # MijResult0 = (-PhaseSlope[0] * cC) / (2*numpy.pi)
1192 1192 MijResult1 = (-PhaseSlope[1] * cC) / (2*numpy.pi)
1193 1193 MijResult2 = (-PhaseSlope[2] * cC) / (2*numpy.pi)
1194 1194 # MijResults = numpy.array([MijResult0, MijResult1, MijResult2])
1195 1195 MijResults = numpy.array([MijResult1, MijResult2])
1196 1196 (cF,cG) = numpy.linalg.solve(MijEijNij, MijResults)
1197 1197
1198 1198 '''****** Getting constants A, B and H ******'''
1199 1199 W01 = numpy.nanmax( FitGauss01 )
1200 1200 W02 = numpy.nanmax( FitGauss02 )
1201 1201 W12 = numpy.nanmax( FitGauss12 )
1202 1202
1203 1203 WijResult01 = ((cF * Xi01 + cG * Eta01)**2)/cC - numpy.log(W01 / numpy.sqrt(numpy.pi / cC))
1204 1204 WijResult02 = ((cF * Xi02 + cG * Eta02)**2)/cC - numpy.log(W02 / numpy.sqrt(numpy.pi / cC))
1205 1205 WijResult12 = ((cF * Xi12 + cG * Eta12)**2)/cC - numpy.log(W12 / numpy.sqrt(numpy.pi / cC))
1206 1206 WijResults = numpy.array([WijResult01, WijResult02, WijResult12])
1207 1207
1208 1208 WijEijNij = numpy.array([ [Xi01**2, Eta01**2, 2*Xi01*Eta01] , [Xi02**2, Eta02**2, 2*Xi02*Eta02] , [Xi12**2, Eta12**2, 2*Xi12*Eta12] ])
1209 1209 (cA,cB,cH) = numpy.linalg.solve(WijEijNij, WijResults)
1210 1210
1211 1211 VxVy = numpy.array([[cA,cH],[cH,cB]])
1212 1212 VxVyResults = numpy.array([-cF,-cG])
1213 1213 (Vmer,Vzon) = numpy.linalg.solve(VxVy, VxVyResults)
1214 1214 Vver = -SPCMoments[1]*SPEED_OF_LIGHT/(2*radfreq)
1215 1215 error_code = 0
1216 1216
1217 1217 return Vzon, Vmer, Vver, error_code
1218 1218
1219 1219 class SpectralMoments(Operation):
1220 1220
1221 1221 '''
1222 1222 Function SpectralMoments()
1223 1223
1224 1224 Calculates moments (power, mean, standard deviation) and SNR of the signal
1225 1225
1226 1226 Type of dataIn: Spectra
1227 1227
1228 1228 Configuration Parameters:
1229 1229
1230 1230 dirCosx : Cosine director in X axis
1231 1231 dirCosy : Cosine director in Y axis
1232 1232
1233 1233 elevation :
1234 1234 azimuth :
1235 1235
1236 1236 Input:
1237 1237 channelList : simple channel list to select e.g. [2,3,7]
1238 1238 self.dataOut.data_pre : Spectral data
1239 1239 self.dataOut.abscissaList : List of frequencies
1240 1240 self.dataOut.noise : Noise level per channel
1241 1241
1242 1242 Affected:
1243 1243 self.dataOut.moments : Parameters per channel
1244 1244 self.dataOut.data_snr : SNR per channel
1245 1245
1246 1246 '''
1247 1247
1248 1248 def run(self, dataOut):
1249 1249
1250 1250 data = dataOut.data_pre[0]
1251 1251 absc = dataOut.abscissaList[:-1]
1252 1252 noise = dataOut.noise
1253 1253 nChannel = data.shape[0]
1254 1254 data_param = numpy.zeros((nChannel, 4, data.shape[2]))
1255 1255
1256 1256 for ind in range(nChannel):
1257 1257 data_param[ind,:,:] = self.__calculateMoments( data[ind,:,:] , absc , noise[ind] )
1258 1258
1259 1259 dataOut.moments = data_param[:,1:,:]
1260 1260 dataOut.data_snr = data_param[:,0]
1261 1261 dataOut.data_pow = data_param[:,1]
1262 1262 dataOut.data_dop = data_param[:,2]
1263 1263 dataOut.data_width = data_param[:,3]
1264 1264 return dataOut
1265 1265
1266 1266 def __calculateMoments(self, oldspec, oldfreq, n0,
1267 1267 nicoh = None, graph = None, smooth = None, type1 = None, fwindow = None, snrth = None, dc = None, aliasing = None, oldfd = None, wwauto = None):
1268 1268
1269 1269 if (nicoh is None): nicoh = 1
1270 1270 if (graph is None): graph = 0
1271 1271 if (smooth is None): smooth = 0
1272 1272 elif (self.smooth < 3): smooth = 0
1273 1273
1274 1274 if (type1 is None): type1 = 0
1275 1275 if (fwindow is None): fwindow = numpy.zeros(oldfreq.size) + 1
1276 1276 if (snrth is None): snrth = -3
1277 1277 if (dc is None): dc = 0
1278 1278 if (aliasing is None): aliasing = 0
1279 1279 if (oldfd is None): oldfd = 0
1280 1280 if (wwauto is None): wwauto = 0
1281 1281
1282 1282 if (n0 < 1.e-20): n0 = 1.e-20
1283 1283
1284 1284 freq = oldfreq
1285 1285 vec_power = numpy.zeros(oldspec.shape[1])
1286 1286 vec_fd = numpy.zeros(oldspec.shape[1])
1287 1287 vec_w = numpy.zeros(oldspec.shape[1])
1288 1288 vec_snr = numpy.zeros(oldspec.shape[1])
1289 1289
1290 1290 # oldspec = numpy.ma.masked_invalid(oldspec)
1291 1291 for ind in range(oldspec.shape[1]):
1292 1292
1293 1293 spec = oldspec[:,ind]
1294 1294 aux = spec*fwindow
1295 1295 max_spec = aux.max()
1296 1296 m = aux.tolist().index(max_spec)
1297 1297
1298 1298 # Smooth
1299 1299 if (smooth == 0):
1300 1300 spec2 = spec
1301 1301 else:
1302 1302 spec2 = scipy.ndimage.filters.uniform_filter1d(spec,size=smooth)
1303 1303
1304 1304 # Moments Estimation
1305 1305 bb = spec2[numpy.arange(m,spec2.size)]
1306 1306 bb = (bb<n0).nonzero()
1307 1307 bb = bb[0]
1308 1308
1309 1309 ss = spec2[numpy.arange(0,m + 1)]
1310 1310 ss = (ss<n0).nonzero()
1311 1311 ss = ss[0]
1312 1312
1313 1313 if (bb.size == 0):
1314 1314 bb0 = spec.size - 1 - m
1315 1315 else:
1316 1316 bb0 = bb[0] - 1
1317 1317 if (bb0 < 0):
1318 1318 bb0 = 0
1319 1319
1320 1320 if (ss.size == 0):
1321 1321 ss1 = 1
1322 1322 else:
1323 1323 ss1 = max(ss) + 1
1324 1324
1325 1325 if (ss1 > m):
1326 1326 ss1 = m
1327 1327
1328 1328 #valid = numpy.arange(int(m + bb0 - ss1 + 1)) + ss1
1329 1329 valid = numpy.arange(1,oldspec.shape[0])# valid perfil completo igual pulsepair
1330 1330 signal_power = ((spec2[valid] - n0) * fwindow[valid]).mean() # D. ScipiΓ³n added with correct definition
1331 1331 total_power = (spec2[valid] * fwindow[valid]).mean() # D. ScipiΓ³n added with correct definition
1332 1332 power = ((spec2[valid] - n0) * fwindow[valid]).sum()
1333 1333 fd = ((spec2[valid]- n0)*freq[valid] * fwindow[valid]).sum() / power
1334 1334 w = numpy.sqrt(((spec2[valid] - n0)*fwindow[valid]*(freq[valid]- fd)**2).sum() / power)
1335 1335 snr = (spec2.mean()-n0)/n0
1336 1336 if (snr < 1.e-20) :
1337 1337 snr = 1.e-20
1338 1338
1339 1339 # vec_power[ind] = power #D. ScipiΓ³n replaced with the line below
1340 1340 vec_power[ind] = total_power
1341 1341 vec_fd[ind] = fd
1342 1342 vec_w[ind] = w
1343 1343 vec_snr[ind] = snr
1344 1344
1345 1345 return numpy.vstack((vec_snr, vec_power, vec_fd, vec_w))
1346 1346
1347 1347 #------------------ Get SA Parameters --------------------------
1348 1348
1349 1349 def GetSAParameters(self):
1350 1350 #SA en frecuencia
1351 1351 pairslist = self.dataOut.groupList
1352 1352 num_pairs = len(pairslist)
1353 1353
1354 1354 vel = self.dataOut.abscissaList
1355 1355 spectra = self.dataOut.data_pre
1356 1356 cspectra = self.dataIn.data_cspc
1357 1357 delta_v = vel[1] - vel[0]
1358 1358
1359 1359 #Calculating the power spectrum
1360 1360 spc_pow = numpy.sum(spectra, 3)*delta_v
1361 1361 #Normalizing Spectra
1362 1362 norm_spectra = spectra/spc_pow
1363 1363 #Calculating the norm_spectra at peak
1364 1364 max_spectra = numpy.max(norm_spectra, 3)
1365 1365
1366 1366 #Normalizing Cross Spectra
1367 1367 norm_cspectra = numpy.zeros(cspectra.shape)
1368 1368
1369 1369 for i in range(num_chan):
1370 1370 norm_cspectra[i,:,:] = cspectra[i,:,:]/numpy.sqrt(spc_pow[pairslist[i][0],:]*spc_pow[pairslist[i][1],:])
1371 1371
1372 1372 max_cspectra = numpy.max(norm_cspectra,2)
1373 1373 max_cspectra_index = numpy.argmax(norm_cspectra, 2)
1374 1374
1375 1375 for i in range(num_pairs):
1376 1376 cspc_par[i,:,:] = __calculateMoments(norm_cspectra)
1377 1377 #------------------- Get Lags ----------------------------------
1378 1378
1379 1379 class SALags(Operation):
1380 1380 '''
1381 1381 Function GetMoments()
1382 1382
1383 1383 Input:
1384 1384 self.dataOut.data_pre
1385 1385 self.dataOut.abscissaList
1386 1386 self.dataOut.noise
1387 1387 self.dataOut.normFactor
1388 1388 self.dataOut.data_snr
1389 1389 self.dataOut.groupList
1390 1390 self.dataOut.nChannels
1391 1391
1392 1392 Affected:
1393 1393 self.dataOut.data_param
1394 1394
1395 1395 '''
1396 1396 def run(self, dataOut):
1397 1397 data_acf = dataOut.data_pre[0]
1398 1398 data_ccf = dataOut.data_pre[1]
1399 1399 normFactor_acf = dataOut.normFactor[0]
1400 1400 normFactor_ccf = dataOut.normFactor[1]
1401 1401 pairs_acf = dataOut.groupList[0]
1402 1402 pairs_ccf = dataOut.groupList[1]
1403 1403
1404 1404 nHeights = dataOut.nHeights
1405 1405 absc = dataOut.abscissaList
1406 1406 noise = dataOut.noise
1407 1407 SNR = dataOut.data_snr
1408 1408 nChannels = dataOut.nChannels
1409 1409 # pairsList = dataOut.groupList
1410 1410 # pairsAutoCorr, pairsCrossCorr = self.__getPairsAutoCorr(pairsList, nChannels)
1411 1411
1412 1412 for l in range(len(pairs_acf)):
1413 1413 data_acf[l,:,:] = data_acf[l,:,:]/normFactor_acf[l,:]
1414 1414
1415 1415 for l in range(len(pairs_ccf)):
1416 1416 data_ccf[l,:,:] = data_ccf[l,:,:]/normFactor_ccf[l,:]
1417 1417
1418 1418 dataOut.data_param = numpy.zeros((len(pairs_ccf)*2 + 1, nHeights))
1419 1419 dataOut.data_param[:-1,:] = self.__calculateTaus(data_acf, data_ccf, absc)
1420 1420 dataOut.data_param[-1,:] = self.__calculateLag1Phase(data_acf, absc)
1421 1421 return
1422 1422
1423 1423 # def __getPairsAutoCorr(self, pairsList, nChannels):
1424 1424 #
1425 1425 # pairsAutoCorr = numpy.zeros(nChannels, dtype = 'int')*numpy.nan
1426 1426 #
1427 1427 # for l in range(len(pairsList)):
1428 1428 # firstChannel = pairsList[l][0]
1429 1429 # secondChannel = pairsList[l][1]
1430 1430 #
1431 1431 # #Obteniendo pares de Autocorrelacion
1432 1432 # if firstChannel == secondChannel:
1433 1433 # pairsAutoCorr[firstChannel] = int(l)
1434 1434 #
1435 1435 # pairsAutoCorr = pairsAutoCorr.astype(int)
1436 1436 #
1437 1437 # pairsCrossCorr = range(len(pairsList))
1438 1438 # pairsCrossCorr = numpy.delete(pairsCrossCorr,pairsAutoCorr)
1439 1439 #
1440 1440 # return pairsAutoCorr, pairsCrossCorr
1441 1441
1442 1442 def __calculateTaus(self, data_acf, data_ccf, lagRange):
1443 1443
1444 1444 lag0 = data_acf.shape[1]/2
1445 1445 #Funcion de Autocorrelacion
1446 1446 mean_acf = stats.nanmean(data_acf, axis = 0)
1447 1447
1448 1448 #Obtencion Indice de TauCross
1449 1449 ind_ccf = data_ccf.argmax(axis = 1)
1450 1450 #Obtencion Indice de TauAuto
1451 1451 ind_acf = numpy.zeros(ind_ccf.shape,dtype = 'int')
1452 1452 ccf_lag0 = data_ccf[:,lag0,:]
1453 1453
1454 1454 for i in range(ccf_lag0.shape[0]):
1455 1455 ind_acf[i,:] = numpy.abs(mean_acf - ccf_lag0[i,:]).argmin(axis = 0)
1456 1456
1457 1457 #Obtencion de TauCross y TauAuto
1458 1458 tau_ccf = lagRange[ind_ccf]
1459 1459 tau_acf = lagRange[ind_acf]
1460 1460
1461 1461 Nan1, Nan2 = numpy.where(tau_ccf == lagRange[0])
1462 1462
1463 1463 tau_ccf[Nan1,Nan2] = numpy.nan
1464 1464 tau_acf[Nan1,Nan2] = numpy.nan
1465 1465 tau = numpy.vstack((tau_ccf,tau_acf))
1466 1466
1467 1467 return tau
1468 1468
1469 1469 def __calculateLag1Phase(self, data, lagTRange):
1470 1470 data1 = stats.nanmean(data, axis = 0)
1471 1471 lag1 = numpy.where(lagTRange == 0)[0][0] + 1
1472 1472
1473 1473 phase = numpy.angle(data1[lag1,:])
1474 1474
1475 1475 return phase
1476 1476
1477 1477 class SpectralFitting(Operation):
1478 1478 '''
1479 1479 Function GetMoments()
1480 1480
1481 1481 Input:
1482 1482 Output:
1483 1483 Variables modified:
1484 1484 '''
1485 1485
1486 1486 def run(self, dataOut, getSNR = True, path=None, file=None, groupList=None):
1487 1487
1488 1488
1489 1489 if path != None:
1490 1490 sys.path.append(path)
1491 1491 self.dataOut.library = importlib.import_module(file)
1492 1492
1493 1493 #To be inserted as a parameter
1494 1494 groupArray = numpy.array(groupList)
1495 1495 # groupArray = numpy.array([[0,1],[2,3]])
1496 1496 self.dataOut.groupList = groupArray
1497 1497
1498 1498 nGroups = groupArray.shape[0]
1499 1499 nChannels = self.dataIn.nChannels
1500 1500 nHeights=self.dataIn.heightList.size
1501 1501
1502 1502 #Parameters Array
1503 1503 self.dataOut.data_param = None
1504 1504
1505 1505 #Set constants
1506 1506 constants = self.dataOut.library.setConstants(self.dataIn)
1507 1507 self.dataOut.constants = constants
1508 1508 M = self.dataIn.normFactor
1509 1509 N = self.dataIn.nFFTPoints
1510 1510 ippSeconds = self.dataIn.ippSeconds
1511 1511 K = self.dataIn.nIncohInt
1512 1512 pairsArray = numpy.array(self.dataIn.pairsList)
1513 1513
1514 1514 #List of possible combinations
1515 1515 listComb = itertools.combinations(numpy.arange(groupArray.shape[1]),2)
1516 1516 indCross = numpy.zeros(len(list(listComb)), dtype = 'int')
1517 1517
1518 1518 if getSNR:
1519 1519 listChannels = groupArray.reshape((groupArray.size))
1520 1520 listChannels.sort()
1521 1521 noise = self.dataIn.getNoise()
1522 1522 self.dataOut.data_snr = self.__getSNR(self.dataIn.data_spc[listChannels,:,:], noise[listChannels])
1523 1523
1524 1524 for i in range(nGroups):
1525 1525 coord = groupArray[i,:]
1526 1526
1527 1527 #Input data array
1528 1528 data = self.dataIn.data_spc[coord,:,:]/(M*N)
1529 1529 data = data.reshape((data.shape[0]*data.shape[1],data.shape[2]))
1530 1530
1531 1531 #Cross Spectra data array for Covariance Matrixes
1532 1532 ind = 0
1533 1533 for pairs in listComb:
1534 1534 pairsSel = numpy.array([coord[x],coord[y]])
1535 1535 indCross[ind] = int(numpy.where(numpy.all(pairsArray == pairsSel, axis = 1))[0][0])
1536 1536 ind += 1
1537 1537 dataCross = self.dataIn.data_cspc[indCross,:,:]/(M*N)
1538 1538 dataCross = dataCross**2/K
1539 1539
1540 1540 for h in range(nHeights):
1541 1541
1542 1542 #Input
1543 1543 d = data[:,h]
1544 1544
1545 1545 #Covariance Matrix
1546 1546 D = numpy.diag(d**2/K)
1547 1547 ind = 0
1548 1548 for pairs in listComb:
1549 1549 #Coordinates in Covariance Matrix
1550 1550 x = pairs[0]
1551 1551 y = pairs[1]
1552 1552 #Channel Index
1553 1553 S12 = dataCross[ind,:,h]
1554 1554 D12 = numpy.diag(S12)
1555 1555 #Completing Covariance Matrix with Cross Spectras
1556 1556 D[x*N:(x+1)*N,y*N:(y+1)*N] = D12
1557 1557 D[y*N:(y+1)*N,x*N:(x+1)*N] = D12
1558 1558 ind += 1
1559 1559 Dinv=numpy.linalg.inv(D)
1560 1560 L=numpy.linalg.cholesky(Dinv)
1561 1561 LT=L.T
1562 1562
1563 1563 dp = numpy.dot(LT,d)
1564 1564
1565 1565 #Initial values
1566 1566 data_spc = self.dataIn.data_spc[coord,:,h]
1567 1567
1568 1568 if (h>0)and(error1[3]<5):
1569 1569 p0 = self.dataOut.data_param[i,:,h-1]
1570 1570 else:
1571 1571 p0 = numpy.array(self.dataOut.library.initialValuesFunction(data_spc, constants, i))
1572 1572
1573 1573 try:
1574 1574 #Least Squares
1575 1575 minp,covp,infodict,mesg,ier = optimize.leastsq(self.__residFunction,p0,args=(dp,LT,constants),full_output=True)
1576 1576 # minp,covp = optimize.leastsq(self.__residFunction,p0,args=(dp,LT,constants))
1577 1577 #Chi square error
1578 1578 error0 = numpy.sum(infodict['fvec']**2)/(2*N)
1579 1579 #Error with Jacobian
1580 1580 error1 = self.dataOut.library.errorFunction(minp,constants,LT)
1581 1581 except:
1582 1582 minp = p0*numpy.nan
1583 1583 error0 = numpy.nan
1584 1584 error1 = p0*numpy.nan
1585 1585
1586 1586 #Save
1587 1587 if self.dataOut.data_param is None:
1588 1588 self.dataOut.data_param = numpy.zeros((nGroups, p0.size, nHeights))*numpy.nan
1589 1589 self.dataOut.data_error = numpy.zeros((nGroups, p0.size + 1, nHeights))*numpy.nan
1590 1590
1591 1591 self.dataOut.data_error[i,:,h] = numpy.hstack((error0,error1))
1592 1592 self.dataOut.data_param[i,:,h] = minp
1593 1593 return
1594 1594
1595 1595 def __residFunction(self, p, dp, LT, constants):
1596 1596
1597 1597 fm = self.dataOut.library.modelFunction(p, constants)
1598 1598 fmp=numpy.dot(LT,fm)
1599 1599
1600 1600 return dp-fmp
1601 1601
1602 1602 def __getSNR(self, z, noise):
1603 1603
1604 1604 avg = numpy.average(z, axis=1)
1605 1605 SNR = (avg.T-noise)/noise
1606 1606 SNR = SNR.T
1607 1607 return SNR
1608 1608
1609 1609 def __chisq(p,chindex,hindex):
1610 1610 #similar to Resid but calculates CHI**2
1611 1611 [LT,d,fm]=setupLTdfm(p,chindex,hindex)
1612 1612 dp=numpy.dot(LT,d)
1613 1613 fmp=numpy.dot(LT,fm)
1614 1614 chisq=numpy.dot((dp-fmp).T,(dp-fmp))
1615 1615 return chisq
1616 1616
1617 1617 class WindProfiler(Operation):
1618 1618
1619 1619 __isConfig = False
1620 1620
1621 1621 __initime = None
1622 1622 __lastdatatime = None
1623 1623 __integrationtime = None
1624 1624
1625 1625 __buffer = None
1626 1626
1627 1627 __dataReady = False
1628 1628
1629 1629 __firstdata = None
1630 1630
1631 1631 n = None
1632 1632
1633 1633 def __init__(self):
1634 1634 Operation.__init__(self)
1635 1635
1636 1636 def __calculateCosDir(self, elev, azim):
1637 1637 zen = (90 - elev)*numpy.pi/180
1638 1638 azim = azim*numpy.pi/180
1639 1639 cosDirX = numpy.sqrt((1-numpy.cos(zen)**2)/((1+numpy.tan(azim)**2)))
1640 1640 cosDirY = numpy.sqrt(1-numpy.cos(zen)**2-cosDirX**2)
1641 1641
1642 1642 signX = numpy.sign(numpy.cos(azim))
1643 1643 signY = numpy.sign(numpy.sin(azim))
1644 1644
1645 1645 cosDirX = numpy.copysign(cosDirX, signX)
1646 1646 cosDirY = numpy.copysign(cosDirY, signY)
1647 1647 return cosDirX, cosDirY
1648 1648
1649 1649 def __calculateAngles(self, theta_x, theta_y, azimuth):
1650 1650
1651 1651 dir_cosw = numpy.sqrt(1-theta_x**2-theta_y**2)
1652 1652 zenith_arr = numpy.arccos(dir_cosw)
1653 1653 azimuth_arr = numpy.arctan2(theta_x,theta_y) + azimuth*math.pi/180
1654 1654
1655 1655 dir_cosu = numpy.sin(azimuth_arr)*numpy.sin(zenith_arr)
1656 1656 dir_cosv = numpy.cos(azimuth_arr)*numpy.sin(zenith_arr)
1657 1657
1658 1658 return azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw
1659 1659
1660 1660 def __calculateMatA(self, dir_cosu, dir_cosv, dir_cosw, horOnly):
1661 1661
1662 1662 #
1663 1663 if horOnly:
1664 1664 A = numpy.c_[dir_cosu,dir_cosv]
1665 1665 else:
1666 1666 A = numpy.c_[dir_cosu,dir_cosv,dir_cosw]
1667 1667 A = numpy.asmatrix(A)
1668 1668 A1 = numpy.linalg.inv(A.transpose()*A)*A.transpose()
1669 1669
1670 1670 return A1
1671 1671
1672 1672 def __correctValues(self, heiRang, phi, velRadial, SNR):
1673 1673 listPhi = phi.tolist()
1674 1674 maxid = listPhi.index(max(listPhi))
1675 1675 minid = listPhi.index(min(listPhi))
1676 1676
1677 1677 rango = list(range(len(phi)))
1678 1678 # rango = numpy.delete(rango,maxid)
1679 1679
1680 1680 heiRang1 = heiRang*math.cos(phi[maxid])
1681 1681 heiRangAux = heiRang*math.cos(phi[minid])
1682 1682 indOut = (heiRang1 < heiRangAux[0]).nonzero()
1683 1683 heiRang1 = numpy.delete(heiRang1,indOut)
1684 1684
1685 1685 velRadial1 = numpy.zeros([len(phi),len(heiRang1)])
1686 1686 SNR1 = numpy.zeros([len(phi),len(heiRang1)])
1687 1687
1688 1688 for i in rango:
1689 1689 x = heiRang*math.cos(phi[i])
1690 1690 y1 = velRadial[i,:]
1691 1691 f1 = interpolate.interp1d(x,y1,kind = 'cubic')
1692 1692
1693 1693 x1 = heiRang1
1694 1694 y11 = f1(x1)
1695 1695
1696 1696 y2 = SNR[i,:]
1697 1697 f2 = interpolate.interp1d(x,y2,kind = 'cubic')
1698 1698 y21 = f2(x1)
1699 1699
1700 1700 velRadial1[i,:] = y11
1701 1701 SNR1[i,:] = y21
1702 1702
1703 1703 return heiRang1, velRadial1, SNR1
1704 1704
1705 1705 def __calculateVelUVW(self, A, velRadial):
1706 1706
1707 1707 #Operacion Matricial
1708 1708 # velUVW = numpy.zeros((velRadial.shape[1],3))
1709 1709 # for ind in range(velRadial.shape[1]):
1710 1710 # velUVW[ind,:] = numpy.dot(A,velRadial[:,ind])
1711 1711 # velUVW = velUVW.transpose()
1712 1712 velUVW = numpy.zeros((A.shape[0],velRadial.shape[1]))
1713 1713 velUVW[:,:] = numpy.dot(A,velRadial)
1714 1714
1715 1715
1716 1716 return velUVW
1717 1717
1718 1718 # def techniqueDBS(self, velRadial0, dirCosx, disrCosy, azimuth, correct, horizontalOnly, heiRang, SNR0):
1719 1719
1720 1720 def techniqueDBS(self, kwargs):
1721 1721 """
1722 1722 Function that implements Doppler Beam Swinging (DBS) technique.
1723 1723
1724 1724 Input: Radial velocities, Direction cosines (x and y) of the Beam, Antenna azimuth,
1725 1725 Direction correction (if necessary), Ranges and SNR
1726 1726
1727 1727 Output: Winds estimation (Zonal, Meridional and Vertical)
1728 1728
1729 1729 Parameters affected: Winds, height range, SNR
1730 1730 """
1731 1731 velRadial0 = kwargs['velRadial']
1732 1732 heiRang = kwargs['heightList']
1733 1733 SNR0 = kwargs['SNR']
1734 1734
1735 1735 if 'dirCosx' in kwargs and 'dirCosy' in kwargs:
1736 1736 theta_x = numpy.array(kwargs['dirCosx'])
1737 1737 theta_y = numpy.array(kwargs['dirCosy'])
1738 1738 else:
1739 1739 elev = numpy.array(kwargs['elevation'])
1740 1740 azim = numpy.array(kwargs['azimuth'])
1741 1741 theta_x, theta_y = self.__calculateCosDir(elev, azim)
1742 1742 azimuth = kwargs['correctAzimuth']
1743 1743 if 'horizontalOnly' in kwargs:
1744 1744 horizontalOnly = kwargs['horizontalOnly']
1745 1745 else: horizontalOnly = False
1746 1746 if 'correctFactor' in kwargs:
1747 1747 correctFactor = kwargs['correctFactor']
1748 1748 else: correctFactor = 1
1749 1749 if 'channelList' in kwargs:
1750 1750 channelList = kwargs['channelList']
1751 1751 if len(channelList) == 2:
1752 1752 horizontalOnly = True
1753 1753 arrayChannel = numpy.array(channelList)
1754 1754 param = param[arrayChannel,:,:]
1755 1755 theta_x = theta_x[arrayChannel]
1756 1756 theta_y = theta_y[arrayChannel]
1757 1757
1758 1758 azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw = self.__calculateAngles(theta_x, theta_y, azimuth)
1759 1759 heiRang1, velRadial1, SNR1 = self.__correctValues(heiRang, zenith_arr, correctFactor*velRadial0, SNR0)
1760 1760 A = self.__calculateMatA(dir_cosu, dir_cosv, dir_cosw, horizontalOnly)
1761 1761
1762 1762 #Calculo de Componentes de la velocidad con DBS
1763 1763 winds = self.__calculateVelUVW(A,velRadial1)
1764 1764
1765 1765 return winds, heiRang1, SNR1
1766 1766
1767 1767 def __calculateDistance(self, posx, posy, pairs_ccf, azimuth = None):
1768 1768
1769 1769 nPairs = len(pairs_ccf)
1770 1770 posx = numpy.asarray(posx)
1771 1771 posy = numpy.asarray(posy)
1772 1772
1773 1773 #Rotacion Inversa para alinear con el azimuth
1774 1774 if azimuth!= None:
1775 1775 azimuth = azimuth*math.pi/180
1776 1776 posx1 = posx*math.cos(azimuth) + posy*math.sin(azimuth)
1777 1777 posy1 = -posx*math.sin(azimuth) + posy*math.cos(azimuth)
1778 1778 else:
1779 1779 posx1 = posx
1780 1780 posy1 = posy
1781 1781
1782 1782 #Calculo de Distancias
1783 1783 distx = numpy.zeros(nPairs)
1784 1784 disty = numpy.zeros(nPairs)
1785 1785 dist = numpy.zeros(nPairs)
1786 1786 ang = numpy.zeros(nPairs)
1787 1787
1788 1788 for i in range(nPairs):
1789 1789 distx[i] = posx1[pairs_ccf[i][1]] - posx1[pairs_ccf[i][0]]
1790 1790 disty[i] = posy1[pairs_ccf[i][1]] - posy1[pairs_ccf[i][0]]
1791 1791 dist[i] = numpy.sqrt(distx[i]**2 + disty[i]**2)
1792 1792 ang[i] = numpy.arctan2(disty[i],distx[i])
1793 1793
1794 1794 return distx, disty, dist, ang
1795 1795 #Calculo de Matrices
1796 1796 # nPairs = len(pairs)
1797 1797 # ang1 = numpy.zeros((nPairs, 2, 1))
1798 1798 # dist1 = numpy.zeros((nPairs, 2, 1))
1799 1799 #
1800 1800 # for j in range(nPairs):
1801 1801 # dist1[j,0,0] = dist[pairs[j][0]]
1802 1802 # dist1[j,1,0] = dist[pairs[j][1]]
1803 1803 # ang1[j,0,0] = ang[pairs[j][0]]
1804 1804 # ang1[j,1,0] = ang[pairs[j][1]]
1805 1805 #
1806 1806 # return distx,disty, dist1,ang1
1807 1807
1808 1808
1809 1809 def __calculateVelVer(self, phase, lagTRange, _lambda):
1810 1810
1811 1811 Ts = lagTRange[1] - lagTRange[0]
1812 1812 velW = -_lambda*phase/(4*math.pi*Ts)
1813 1813
1814 1814 return velW
1815 1815
1816 1816 def __calculateVelHorDir(self, dist, tau1, tau2, ang):
1817 1817 nPairs = tau1.shape[0]
1818 1818 nHeights = tau1.shape[1]
1819 1819 vel = numpy.zeros((nPairs,3,nHeights))
1820 1820 dist1 = numpy.reshape(dist, (dist.size,1))
1821 1821
1822 1822 angCos = numpy.cos(ang)
1823 1823 angSin = numpy.sin(ang)
1824 1824
1825 1825 vel0 = dist1*tau1/(2*tau2**2)
1826 1826 vel[:,0,:] = (vel0*angCos).sum(axis = 1)
1827 1827 vel[:,1,:] = (vel0*angSin).sum(axis = 1)
1828 1828
1829 1829 ind = numpy.where(numpy.isinf(vel))
1830 1830 vel[ind] = numpy.nan
1831 1831
1832 1832 return vel
1833 1833
1834 1834 # def __getPairsAutoCorr(self, pairsList, nChannels):
1835 1835 #
1836 1836 # pairsAutoCorr = numpy.zeros(nChannels, dtype = 'int')*numpy.nan
1837 1837 #
1838 1838 # for l in range(len(pairsList)):
1839 1839 # firstChannel = pairsList[l][0]
1840 1840 # secondChannel = pairsList[l][1]
1841 1841 #
1842 1842 # #Obteniendo pares de Autocorrelacion
1843 1843 # if firstChannel == secondChannel:
1844 1844 # pairsAutoCorr[firstChannel] = int(l)
1845 1845 #
1846 1846 # pairsAutoCorr = pairsAutoCorr.astype(int)
1847 1847 #
1848 1848 # pairsCrossCorr = range(len(pairsList))
1849 1849 # pairsCrossCorr = numpy.delete(pairsCrossCorr,pairsAutoCorr)
1850 1850 #
1851 1851 # return pairsAutoCorr, pairsCrossCorr
1852 1852
1853 1853 # def techniqueSA(self, pairsSelected, pairsList, nChannels, tau, azimuth, _lambda, position_x, position_y, lagTRange, correctFactor):
1854 1854 def techniqueSA(self, kwargs):
1855 1855
1856 1856 """
1857 1857 Function that implements Spaced Antenna (SA) technique.
1858 1858
1859 1859 Input: Radial velocities, Direction cosines (x and y) of the Beam, Antenna azimuth,
1860 1860 Direction correction (if necessary), Ranges and SNR
1861 1861
1862 1862 Output: Winds estimation (Zonal, Meridional and Vertical)
1863 1863
1864 1864 Parameters affected: Winds
1865 1865 """
1866 1866 position_x = kwargs['positionX']
1867 1867 position_y = kwargs['positionY']
1868 1868 azimuth = kwargs['azimuth']
1869 1869
1870 1870 if 'correctFactor' in kwargs:
1871 1871 correctFactor = kwargs['correctFactor']
1872 1872 else:
1873 1873 correctFactor = 1
1874 1874
1875 1875 groupList = kwargs['groupList']
1876 1876 pairs_ccf = groupList[1]
1877 1877 tau = kwargs['tau']
1878 1878 _lambda = kwargs['_lambda']
1879 1879
1880 1880 #Cross Correlation pairs obtained
1881 1881 # pairsAutoCorr, pairsCrossCorr = self.__getPairsAutoCorr(pairssList, nChannels)
1882 1882 # pairsArray = numpy.array(pairsList)[pairsCrossCorr]
1883 1883 # pairsSelArray = numpy.array(pairsSelected)
1884 1884 # pairs = []
1885 1885 #
1886 1886 # #Wind estimation pairs obtained
1887 1887 # for i in range(pairsSelArray.shape[0]/2):
1888 1888 # ind1 = numpy.where(numpy.all(pairsArray == pairsSelArray[2*i], axis = 1))[0][0]
1889 1889 # ind2 = numpy.where(numpy.all(pairsArray == pairsSelArray[2*i + 1], axis = 1))[0][0]
1890 1890 # pairs.append((ind1,ind2))
1891 1891
1892 1892 indtau = tau.shape[0]/2
1893 1893 tau1 = tau[:indtau,:]
1894 1894 tau2 = tau[indtau:-1,:]
1895 1895 # tau1 = tau1[pairs,:]
1896 1896 # tau2 = tau2[pairs,:]
1897 1897 phase1 = tau[-1,:]
1898 1898
1899 1899 #---------------------------------------------------------------------
1900 1900 #Metodo Directo
1901 1901 distx, disty, dist, ang = self.__calculateDistance(position_x, position_y, pairs_ccf,azimuth)
1902 1902 winds = self.__calculateVelHorDir(dist, tau1, tau2, ang)
1903 1903 winds = stats.nanmean(winds, axis=0)
1904 1904 #---------------------------------------------------------------------
1905 1905 #Metodo General
1906 1906 # distx, disty, dist = self.calculateDistance(position_x,position_y,pairsCrossCorr, pairsList, azimuth)
1907 1907 # #Calculo Coeficientes de Funcion de Correlacion
1908 1908 # F,G,A,B,H = self.calculateCoef(tau1,tau2,distx,disty,n)
1909 1909 # #Calculo de Velocidades
1910 1910 # winds = self.calculateVelUV(F,G,A,B,H)
1911 1911
1912 1912 #---------------------------------------------------------------------
1913 1913 winds[2,:] = self.__calculateVelVer(phase1, lagTRange, _lambda)
1914 1914 winds = correctFactor*winds
1915 1915 return winds
1916 1916
1917 1917 def __checkTime(self, currentTime, paramInterval, outputInterval):
1918 1918
1919 1919 dataTime = currentTime + paramInterval
1920 1920 deltaTime = dataTime - self.__initime
1921 1921
1922 1922 if deltaTime >= outputInterval or deltaTime < 0:
1923 1923 self.__dataReady = True
1924 1924 return
1925 1925
1926 1926 def techniqueMeteors(self, arrayMeteor, meteorThresh, heightMin, heightMax):
1927 1927 '''
1928 1928 Function that implements winds estimation technique with detected meteors.
1929 1929
1930 1930 Input: Detected meteors, Minimum meteor quantity to wind estimation
1931 1931
1932 1932 Output: Winds estimation (Zonal and Meridional)
1933 1933
1934 1934 Parameters affected: Winds
1935 1935 '''
1936 1936 #Settings
1937 1937 nInt = (heightMax - heightMin)/2
1938 1938 nInt = int(nInt)
1939 1939 winds = numpy.zeros((2,nInt))*numpy.nan
1940 1940
1941 1941 #Filter errors
1942 1942 error = numpy.where(arrayMeteor[:,-1] == 0)[0]
1943 1943 finalMeteor = arrayMeteor[error,:]
1944 1944
1945 1945 #Meteor Histogram
1946 1946 finalHeights = finalMeteor[:,2]
1947 1947 hist = numpy.histogram(finalHeights, bins = nInt, range = (heightMin,heightMax))
1948 1948 nMeteorsPerI = hist[0]
1949 1949 heightPerI = hist[1]
1950 1950
1951 1951 #Sort of meteors
1952 1952 indSort = finalHeights.argsort()
1953 1953 finalMeteor2 = finalMeteor[indSort,:]
1954 1954
1955 1955 # Calculating winds
1956 1956 ind1 = 0
1957 1957 ind2 = 0
1958 1958
1959 1959 for i in range(nInt):
1960 1960 nMet = nMeteorsPerI[i]
1961 1961 ind1 = ind2
1962 1962 ind2 = ind1 + nMet
1963 1963
1964 1964 meteorAux = finalMeteor2[ind1:ind2,:]
1965 1965
1966 1966 if meteorAux.shape[0] >= meteorThresh:
1967 1967 vel = meteorAux[:, 6]
1968 1968 zen = meteorAux[:, 4]*numpy.pi/180
1969 1969 azim = meteorAux[:, 3]*numpy.pi/180
1970 1970
1971 1971 n = numpy.cos(zen)
1972 1972 # m = (1 - n**2)/(1 - numpy.tan(azim)**2)
1973 1973 # l = m*numpy.tan(azim)
1974 1974 l = numpy.sin(zen)*numpy.sin(azim)
1975 1975 m = numpy.sin(zen)*numpy.cos(azim)
1976 1976
1977 1977 A = numpy.vstack((l, m)).transpose()
1978 1978 A1 = numpy.dot(numpy.linalg.inv( numpy.dot(A.transpose(),A) ),A.transpose())
1979 1979 windsAux = numpy.dot(A1, vel)
1980 1980
1981 1981 winds[0,i] = windsAux[0]
1982 1982 winds[1,i] = windsAux[1]
1983 1983
1984 1984 return winds, heightPerI[:-1]
1985 1985
1986 1986 def techniqueNSM_SA(self, **kwargs):
1987 1987 metArray = kwargs['metArray']
1988 1988 heightList = kwargs['heightList']
1989 1989 timeList = kwargs['timeList']
1990 1990
1991 1991 rx_location = kwargs['rx_location']
1992 1992 groupList = kwargs['groupList']
1993 1993 azimuth = kwargs['azimuth']
1994 1994 dfactor = kwargs['dfactor']
1995 1995 k = kwargs['k']
1996 1996
1997 1997 azimuth1, dist = self.__calculateAzimuth1(rx_location, groupList, azimuth)
1998 1998 d = dist*dfactor
1999 1999 #Phase calculation
2000 2000 metArray1 = self.__getPhaseSlope(metArray, heightList, timeList)
2001 2001
2002 2002 metArray1[:,-2] = metArray1[:,-2]*metArray1[:,2]*1000/(k*d[metArray1[:,1].astype(int)]) #angles into velocities
2003 2003
2004 2004 velEst = numpy.zeros((heightList.size,2))*numpy.nan
2005 2005 azimuth1 = azimuth1*numpy.pi/180
2006 2006
2007 2007 for i in range(heightList.size):
2008 2008 h = heightList[i]
2009 2009 indH = numpy.where((metArray1[:,2] == h)&(numpy.abs(metArray1[:,-2]) < 100))[0]
2010 2010 metHeight = metArray1[indH,:]
2011 2011 if metHeight.shape[0] >= 2:
2012 2012 velAux = numpy.asmatrix(metHeight[:,-2]).T #Radial Velocities
2013 2013 iazim = metHeight[:,1].astype(int)
2014 2014 azimAux = numpy.asmatrix(azimuth1[iazim]).T #Azimuths
2015 2015 A = numpy.hstack((numpy.cos(azimAux),numpy.sin(azimAux)))
2016 2016 A = numpy.asmatrix(A)
2017 2017 A1 = numpy.linalg.pinv(A.transpose()*A)*A.transpose()
2018 2018 velHor = numpy.dot(A1,velAux)
2019 2019
2020 2020 velEst[i,:] = numpy.squeeze(velHor)
2021 2021 return velEst
2022 2022
2023 2023 def __getPhaseSlope(self, metArray, heightList, timeList):
2024 2024 meteorList = []
2025 2025 #utctime sec1 height SNR velRad ph0 ph1 ph2 coh0 coh1 coh2
2026 2026 #Putting back together the meteor matrix
2027 2027 utctime = metArray[:,0]
2028 2028 uniqueTime = numpy.unique(utctime)
2029 2029
2030 2030 phaseDerThresh = 0.5
2031 2031 ippSeconds = timeList[1] - timeList[0]
2032 2032 sec = numpy.where(timeList>1)[0][0]
2033 2033 nPairs = metArray.shape[1] - 6
2034 2034 nHeights = len(heightList)
2035 2035
2036 2036 for t in uniqueTime:
2037 2037 metArray1 = metArray[utctime==t,:]
2038 2038 # phaseDerThresh = numpy.pi/4 #reducir Phase thresh
2039 2039 tmet = metArray1[:,1].astype(int)
2040 2040 hmet = metArray1[:,2].astype(int)
2041 2041
2042 2042 metPhase = numpy.zeros((nPairs, heightList.size, timeList.size - 1))
2043 2043 metPhase[:,:] = numpy.nan
2044 2044 metPhase[:,hmet,tmet] = metArray1[:,6:].T
2045 2045
2046 2046 #Delete short trails
2047 2047 metBool = ~numpy.isnan(metPhase[0,:,:])
2048 2048 heightVect = numpy.sum(metBool, axis = 1)
2049 2049 metBool[heightVect<sec,:] = False
2050 2050 metPhase[:,heightVect<sec,:] = numpy.nan
2051 2051
2052 2052 #Derivative
2053 2053 metDer = numpy.abs(metPhase[:,:,1:] - metPhase[:,:,:-1])
2054 2054 phDerAux = numpy.dstack((numpy.full((nPairs,nHeights,1), False, dtype=bool),metDer > phaseDerThresh))
2055 2055 metPhase[phDerAux] = numpy.nan
2056 2056
2057 2057 #--------------------------METEOR DETECTION -----------------------------------------
2058 2058 indMet = numpy.where(numpy.any(metBool,axis=1))[0]
2059 2059
2060 2060 for p in numpy.arange(nPairs):
2061 2061 phase = metPhase[p,:,:]
2062 2062 phDer = metDer[p,:,:]
2063 2063
2064 2064 for h in indMet:
2065 2065 height = heightList[h]
2066 2066 phase1 = phase[h,:] #82
2067 2067 phDer1 = phDer[h,:]
2068 2068
2069 2069 phase1[~numpy.isnan(phase1)] = numpy.unwrap(phase1[~numpy.isnan(phase1)]) #Unwrap
2070 2070
2071 2071 indValid = numpy.where(~numpy.isnan(phase1))[0]
2072 2072 initMet = indValid[0]
2073 2073 endMet = 0
2074 2074
2075 2075 for i in range(len(indValid)-1):
2076 2076
2077 2077 #Time difference
2078 2078 inow = indValid[i]
2079 2079 inext = indValid[i+1]
2080 2080 idiff = inext - inow
2081 2081 #Phase difference
2082 2082 phDiff = numpy.abs(phase1[inext] - phase1[inow])
2083 2083
2084 2084 if idiff>sec or phDiff>numpy.pi/4 or inext==indValid[-1]: #End of Meteor
2085 2085 sizeTrail = inow - initMet + 1
2086 2086 if sizeTrail>3*sec: #Too short meteors
2087 2087 x = numpy.arange(initMet,inow+1)*ippSeconds
2088 2088 y = phase1[initMet:inow+1]
2089 2089 ynnan = ~numpy.isnan(y)
2090 2090 x = x[ynnan]
2091 2091 y = y[ynnan]
2092 2092 slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)
2093 2093 ylin = x*slope + intercept
2094 2094 rsq = r_value**2
2095 2095 if rsq > 0.5:
2096 2096 vel = slope#*height*1000/(k*d)
2097 2097 estAux = numpy.array([utctime,p,height, vel, rsq])
2098 2098 meteorList.append(estAux)
2099 2099 initMet = inext
2100 2100 metArray2 = numpy.array(meteorList)
2101 2101
2102 2102 return metArray2
2103 2103
2104 2104 def __calculateAzimuth1(self, rx_location, pairslist, azimuth0):
2105 2105
2106 2106 azimuth1 = numpy.zeros(len(pairslist))
2107 2107 dist = numpy.zeros(len(pairslist))
2108 2108
2109 2109 for i in range(len(rx_location)):
2110 2110 ch0 = pairslist[i][0]
2111 2111 ch1 = pairslist[i][1]
2112 2112
2113 2113 diffX = rx_location[ch0][0] - rx_location[ch1][0]
2114 2114 diffY = rx_location[ch0][1] - rx_location[ch1][1]
2115 2115 azimuth1[i] = numpy.arctan2(diffY,diffX)*180/numpy.pi
2116 2116 dist[i] = numpy.sqrt(diffX**2 + diffY**2)
2117 2117
2118 2118 azimuth1 -= azimuth0
2119 2119 return azimuth1, dist
2120 2120
2121 2121 def techniqueNSM_DBS(self, **kwargs):
2122 2122 metArray = kwargs['metArray']
2123 2123 heightList = kwargs['heightList']
2124 2124 timeList = kwargs['timeList']
2125 2125 azimuth = kwargs['azimuth']
2126 2126 theta_x = numpy.array(kwargs['theta_x'])
2127 2127 theta_y = numpy.array(kwargs['theta_y'])
2128 2128
2129 2129 utctime = metArray[:,0]
2130 2130 cmet = metArray[:,1].astype(int)
2131 2131 hmet = metArray[:,3].astype(int)
2132 2132 SNRmet = metArray[:,4]
2133 2133 vmet = metArray[:,5]
2134 2134 spcmet = metArray[:,6]
2135 2135
2136 2136 nChan = numpy.max(cmet) + 1
2137 2137 nHeights = len(heightList)
2138 2138
2139 2139 azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw = self.__calculateAngles(theta_x, theta_y, azimuth)
2140 2140 hmet = heightList[hmet]
2141 2141 h1met = hmet*numpy.cos(zenith_arr[cmet]) #Corrected heights
2142 2142
2143 2143 velEst = numpy.zeros((heightList.size,2))*numpy.nan
2144 2144
2145 2145 for i in range(nHeights - 1):
2146 2146 hmin = heightList[i]
2147 2147 hmax = heightList[i + 1]
2148 2148
2149 2149 thisH = (h1met>=hmin) & (h1met<hmax) & (cmet!=2) & (SNRmet>8) & (vmet<50) & (spcmet<10)
2150 2150 indthisH = numpy.where(thisH)
2151 2151
2152 2152 if numpy.size(indthisH) > 3:
2153 2153
2154 2154 vel_aux = vmet[thisH]
2155 2155 chan_aux = cmet[thisH]
2156 2156 cosu_aux = dir_cosu[chan_aux]
2157 2157 cosv_aux = dir_cosv[chan_aux]
2158 2158 cosw_aux = dir_cosw[chan_aux]
2159 2159
2160 2160 nch = numpy.size(numpy.unique(chan_aux))
2161 2161 if nch > 1:
2162 2162 A = self.__calculateMatA(cosu_aux, cosv_aux, cosw_aux, True)
2163 2163 velEst[i,:] = numpy.dot(A,vel_aux)
2164 2164
2165 2165 return velEst
2166 2166
2167 2167 def run(self, dataOut, technique, nHours=1, hmin=70, hmax=110, **kwargs):
2168 2168
2169 2169 param = dataOut.data_param
2170 2170 if dataOut.abscissaList != None:
2171 2171 absc = dataOut.abscissaList[:-1]
2172 2172 # noise = dataOut.noise
2173 2173 heightList = dataOut.heightList
2174 2174 SNR = dataOut.data_snr
2175 2175
2176 2176 if technique == 'DBS':
2177 2177
2178 2178 kwargs['velRadial'] = param[:,1,:] #Radial velocity
2179 2179 kwargs['heightList'] = heightList
2180 2180 kwargs['SNR'] = SNR
2181 2181
2182 2182 dataOut.data_output, dataOut.heightList, dataOut.data_snr = self.techniqueDBS(kwargs) #DBS Function
2183 2183 dataOut.utctimeInit = dataOut.utctime
2184 2184 dataOut.outputInterval = dataOut.paramInterval
2185 2185
2186 2186 elif technique == 'SA':
2187 2187
2188 2188 #Parameters
2189 2189 # position_x = kwargs['positionX']
2190 2190 # position_y = kwargs['positionY']
2191 2191 # azimuth = kwargs['azimuth']
2192 2192 #
2193 2193 # if kwargs.has_key('crosspairsList'):
2194 2194 # pairs = kwargs['crosspairsList']
2195 2195 # else:
2196 2196 # pairs = None
2197 2197 #
2198 2198 # if kwargs.has_key('correctFactor'):
2199 2199 # correctFactor = kwargs['correctFactor']
2200 2200 # else:
2201 2201 # correctFactor = 1
2202 2202
2203 2203 # tau = dataOut.data_param
2204 2204 # _lambda = dataOut.C/dataOut.frequency
2205 2205 # pairsList = dataOut.groupList
2206 2206 # nChannels = dataOut.nChannels
2207 2207
2208 2208 kwargs['groupList'] = dataOut.groupList
2209 2209 kwargs['tau'] = dataOut.data_param
2210 2210 kwargs['_lambda'] = dataOut.C/dataOut.frequency
2211 2211 # dataOut.data_output = self.techniqueSA(pairs, pairsList, nChannels, tau, azimuth, _lambda, position_x, position_y, absc, correctFactor)
2212 2212 dataOut.data_output = self.techniqueSA(kwargs)
2213 2213 dataOut.utctimeInit = dataOut.utctime
2214 2214 dataOut.outputInterval = dataOut.timeInterval
2215 2215
2216 2216 elif technique == 'Meteors':
2217 2217 dataOut.flagNoData = True
2218 2218 self.__dataReady = False
2219 2219
2220 2220 if 'nHours' in kwargs:
2221 2221 nHours = kwargs['nHours']
2222 2222 else:
2223 2223 nHours = 1
2224 2224
2225 2225 if 'meteorsPerBin' in kwargs:
2226 2226 meteorThresh = kwargs['meteorsPerBin']
2227 2227 else:
2228 2228 meteorThresh = 6
2229 2229
2230 2230 if 'hmin' in kwargs:
2231 2231 hmin = kwargs['hmin']
2232 2232 else: hmin = 70
2233 2233 if 'hmax' in kwargs:
2234 2234 hmax = kwargs['hmax']
2235 2235 else: hmax = 110
2236 2236
2237 2237 dataOut.outputInterval = nHours*3600
2238 2238
2239 2239 if self.__isConfig == False:
2240 2240 # self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
2241 2241 #Get Initial LTC time
2242 2242 self.__initime = datetime.datetime.utcfromtimestamp(dataOut.utctime)
2243 2243 self.__initime = (self.__initime.replace(minute = 0, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
2244 2244
2245 2245 self.__isConfig = True
2246 2246
2247 2247 if self.__buffer is None:
2248 2248 self.__buffer = dataOut.data_param
2249 2249 self.__firstdata = copy.copy(dataOut)
2250 2250
2251 2251 else:
2252 2252 self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
2253 2253
2254 2254 self.__checkTime(dataOut.utctime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
2255 2255
2256 2256 if self.__dataReady:
2257 2257 dataOut.utctimeInit = self.__initime
2258 2258
2259 2259 self.__initime += dataOut.outputInterval #to erase time offset
2260 2260
2261 2261 dataOut.data_output, dataOut.heightList = self.techniqueMeteors(self.__buffer, meteorThresh, hmin, hmax)
2262 2262 dataOut.flagNoData = False
2263 2263 self.__buffer = None
2264 2264
2265 2265 elif technique == 'Meteors1':
2266 2266 dataOut.flagNoData = True
2267 2267 self.__dataReady = False
2268 2268
2269 2269 if 'nMins' in kwargs:
2270 2270 nMins = kwargs['nMins']
2271 2271 else: nMins = 20
2272 2272 if 'rx_location' in kwargs:
2273 2273 rx_location = kwargs['rx_location']
2274 2274 else: rx_location = [(0,1),(1,1),(1,0)]
2275 2275 if 'azimuth' in kwargs:
2276 2276 azimuth = kwargs['azimuth']
2277 2277 else: azimuth = 51.06
2278 2278 if 'dfactor' in kwargs:
2279 2279 dfactor = kwargs['dfactor']
2280 2280 if 'mode' in kwargs:
2281 2281 mode = kwargs['mode']
2282 2282 if 'theta_x' in kwargs:
2283 2283 theta_x = kwargs['theta_x']
2284 2284 if 'theta_y' in kwargs:
2285 2285 theta_y = kwargs['theta_y']
2286 2286 else: mode = 'SA'
2287 2287
2288 2288 #Borrar luego esto
2289 2289 if dataOut.groupList is None:
2290 2290 dataOut.groupList = [(0,1),(0,2),(1,2)]
2291 2291 groupList = dataOut.groupList
2292 2292 C = 3e8
2293 2293 freq = 50e6
2294 2294 lamb = C/freq
2295 2295 k = 2*numpy.pi/lamb
2296 2296
2297 2297 timeList = dataOut.abscissaList
2298 2298 heightList = dataOut.heightList
2299 2299
2300 2300 if self.__isConfig == False:
2301 2301 dataOut.outputInterval = nMins*60
2302 2302 # self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
2303 2303 #Get Initial LTC time
2304 2304 initime = datetime.datetime.utcfromtimestamp(dataOut.utctime)
2305 2305 minuteAux = initime.minute
2306 2306 minuteNew = int(numpy.floor(minuteAux/nMins)*nMins)
2307 2307 self.__initime = (initime.replace(minute = minuteNew, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
2308 2308
2309 2309 self.__isConfig = True
2310 2310
2311 2311 if self.__buffer is None:
2312 2312 self.__buffer = dataOut.data_param
2313 2313 self.__firstdata = copy.copy(dataOut)
2314 2314
2315 2315 else:
2316 2316 self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
2317 2317
2318 2318 self.__checkTime(dataOut.utctime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
2319 2319
2320 2320 if self.__dataReady:
2321 2321 dataOut.utctimeInit = self.__initime
2322 2322 self.__initime += dataOut.outputInterval #to erase time offset
2323 2323
2324 2324 metArray = self.__buffer
2325 2325 if mode == 'SA':
2326 2326 dataOut.data_output = self.techniqueNSM_SA(rx_location=rx_location, groupList=groupList, azimuth=azimuth, dfactor=dfactor, k=k,metArray=metArray, heightList=heightList,timeList=timeList)
2327 2327 elif mode == 'DBS':
2328 2328 dataOut.data_output = self.techniqueNSM_DBS(metArray=metArray,heightList=heightList,timeList=timeList, azimuth=azimuth, theta_x=theta_x, theta_y=theta_y)
2329 2329 dataOut.data_output = dataOut.data_output.T
2330 2330 dataOut.flagNoData = False
2331 2331 self.__buffer = None
2332 2332
2333 2333 return
2334 2334
2335 2335 class EWDriftsEstimation(Operation):
2336 2336
2337 2337 def __init__(self):
2338 2338 Operation.__init__(self)
2339 2339
2340 2340 def __correctValues(self, heiRang, phi, velRadial, SNR):
2341 2341 listPhi = phi.tolist()
2342 2342 maxid = listPhi.index(max(listPhi))
2343 2343 minid = listPhi.index(min(listPhi))
2344 2344
2345 2345 rango = list(range(len(phi)))
2346 2346 # rango = numpy.delete(rango,maxid)
2347 2347
2348 2348 heiRang1 = heiRang*math.cos(phi[maxid])
2349 2349 heiRangAux = heiRang*math.cos(phi[minid])
2350 2350 indOut = (heiRang1 < heiRangAux[0]).nonzero()
2351 2351 heiRang1 = numpy.delete(heiRang1,indOut)
2352 2352
2353 2353 velRadial1 = numpy.zeros([len(phi),len(heiRang1)])
2354 2354 SNR1 = numpy.zeros([len(phi),len(heiRang1)])
2355 2355
2356 2356 for i in rango:
2357 2357 x = heiRang*math.cos(phi[i])
2358 2358 y1 = velRadial[i,:]
2359 2359 f1 = interpolate.interp1d(x,y1,kind = 'cubic')
2360 2360
2361 2361 x1 = heiRang1
2362 2362 y11 = f1(x1)
2363 2363
2364 2364 y2 = SNR[i,:]
2365 2365 f2 = interpolate.interp1d(x,y2,kind = 'cubic')
2366 2366 y21 = f2(x1)
2367 2367
2368 2368 velRadial1[i,:] = y11
2369 2369 SNR1[i,:] = y21
2370 2370
2371 2371 return heiRang1, velRadial1, SNR1
2372 2372
2373 2373 def run(self, dataOut, zenith, zenithCorrection):
2374 2374 heiRang = dataOut.heightList
2375 2375 velRadial = dataOut.data_param[:,3,:]
2376 2376 SNR = dataOut.data_snr
2377 2377
2378 2378 zenith = numpy.array(zenith)
2379 2379 zenith -= zenithCorrection
2380 2380 zenith *= numpy.pi/180
2381 2381
2382 2382 heiRang1, velRadial1, SNR1 = self.__correctValues(heiRang, numpy.abs(zenith), velRadial, SNR)
2383 2383
2384 2384 alp = zenith[0]
2385 2385 bet = zenith[1]
2386 2386
2387 2387 w_w = velRadial1[0,:]
2388 2388 w_e = velRadial1[1,:]
2389 2389
2390 2390 w = (w_w*numpy.sin(bet) - w_e*numpy.sin(alp))/(numpy.cos(alp)*numpy.sin(bet) - numpy.cos(bet)*numpy.sin(alp))
2391 2391 u = (w_w*numpy.cos(bet) - w_e*numpy.cos(alp))/(numpy.sin(alp)*numpy.cos(bet) - numpy.sin(bet)*numpy.cos(alp))
2392 2392
2393 2393 winds = numpy.vstack((u,w))
2394 2394
2395 2395 dataOut.heightList = heiRang1
2396 2396 dataOut.data_output = winds
2397 2397 dataOut.data_snr = SNR1
2398 2398
2399 2399 dataOut.utctimeInit = dataOut.utctime
2400 2400 dataOut.outputInterval = dataOut.timeInterval
2401 2401 return
2402 2402
2403 2403 #--------------- Non Specular Meteor ----------------
2404 2404
2405 2405 class NonSpecularMeteorDetection(Operation):
2406 2406
2407 2407 def run(self, dataOut, mode, SNRthresh=8, phaseDerThresh=0.5, cohThresh=0.8, allData = False):
2408 2408 data_acf = dataOut.data_pre[0]
2409 2409 data_ccf = dataOut.data_pre[1]
2410 2410 pairsList = dataOut.groupList[1]
2411 2411
2412 2412 lamb = dataOut.C/dataOut.frequency
2413 2413 tSamp = dataOut.ippSeconds*dataOut.nCohInt
2414 2414 paramInterval = dataOut.paramInterval
2415 2415
2416 2416 nChannels = data_acf.shape[0]
2417 2417 nLags = data_acf.shape[1]
2418 2418 nProfiles = data_acf.shape[2]
2419 2419 nHeights = dataOut.nHeights
2420 2420 nCohInt = dataOut.nCohInt
2421 2421 sec = numpy.round(nProfiles/dataOut.paramInterval)
2422 2422 heightList = dataOut.heightList
2423 2423 ippSeconds = dataOut.ippSeconds*dataOut.nCohInt*dataOut.nAvg
2424 2424 utctime = dataOut.utctime
2425 2425
2426 2426 dataOut.abscissaList = numpy.arange(0,paramInterval+ippSeconds,ippSeconds)
2427 2427
2428 2428 #------------------------ SNR --------------------------------------
2429 2429 power = data_acf[:,0,:,:].real
2430 2430 noise = numpy.zeros(nChannels)
2431 2431 SNR = numpy.zeros(power.shape)
2432 2432 for i in range(nChannels):
2433 2433 noise[i] = hildebrand_sekhon(power[i,:], nCohInt)
2434 2434 SNR[i] = (power[i]-noise[i])/noise[i]
2435 2435 SNRm = numpy.nanmean(SNR, axis = 0)
2436 2436 SNRdB = 10*numpy.log10(SNR)
2437 2437
2438 2438 if mode == 'SA':
2439 2439 dataOut.groupList = dataOut.groupList[1]
2440 2440 nPairs = data_ccf.shape[0]
2441 2441 #---------------------- Coherence and Phase --------------------------
2442 2442 phase = numpy.zeros(data_ccf[:,0,:,:].shape)
2443 2443 # phase1 = numpy.copy(phase)
2444 2444 coh1 = numpy.zeros(data_ccf[:,0,:,:].shape)
2445 2445
2446 2446 for p in range(nPairs):
2447 2447 ch0 = pairsList[p][0]
2448 2448 ch1 = pairsList[p][1]
2449 2449 ccf = data_ccf[p,0,:,:]/numpy.sqrt(data_acf[ch0,0,:,:]*data_acf[ch1,0,:,:])
2450 2450 phase[p,:,:] = ndimage.median_filter(numpy.angle(ccf), size = (5,1)) #median filter
2451 2451 # phase1[p,:,:] = numpy.angle(ccf) #median filter
2452 2452 coh1[p,:,:] = ndimage.median_filter(numpy.abs(ccf), 5) #median filter
2453 2453 # coh1[p,:,:] = numpy.abs(ccf) #median filter
2454 2454 coh = numpy.nanmax(coh1, axis = 0)
2455 2455 # struc = numpy.ones((5,1))
2456 2456 # coh = ndimage.morphology.grey_dilation(coh, size=(10,1))
2457 2457 #---------------------- Radial Velocity ----------------------------
2458 2458 phaseAux = numpy.mean(numpy.angle(data_acf[:,1,:,:]), axis = 0)
2459 2459 velRad = phaseAux*lamb/(4*numpy.pi*tSamp)
2460 2460
2461 2461 if allData:
2462 2462 boolMetFin = ~numpy.isnan(SNRm)
2463 2463 # coh[:-1,:] = numpy.nanmean(numpy.abs(phase[:,1:,:] - phase[:,:-1,:]),axis=0)
2464 2464 else:
2465 2465 #------------------------ Meteor mask ---------------------------------
2466 2466 # #SNR mask
2467 2467 # boolMet = (SNRdB>SNRthresh)#|(~numpy.isnan(SNRdB))
2468 2468 #
2469 2469 # #Erase small objects
2470 2470 # boolMet1 = self.__erase_small(boolMet, 2*sec, 5)
2471 2471 #
2472 2472 # auxEEJ = numpy.sum(boolMet1,axis=0)
2473 2473 # indOver = auxEEJ>nProfiles*0.8 #Use this later
2474 2474 # indEEJ = numpy.where(indOver)[0]
2475 2475 # indNEEJ = numpy.where(~indOver)[0]
2476 2476 #
2477 2477 # boolMetFin = boolMet1
2478 2478 #
2479 2479 # if indEEJ.size > 0:
2480 2480 # boolMet1[:,indEEJ] = False #Erase heights with EEJ
2481 2481 #
2482 2482 # boolMet2 = coh > cohThresh
2483 2483 # boolMet2 = self.__erase_small(boolMet2, 2*sec,5)
2484 2484 #
2485 2485 # #Final Meteor mask
2486 2486 # boolMetFin = boolMet1|boolMet2
2487 2487
2488 2488 #Coherence mask
2489 2489 boolMet1 = coh > 0.75
2490 2490 struc = numpy.ones((30,1))
2491 2491 boolMet1 = ndimage.morphology.binary_dilation(boolMet1, structure=struc)
2492 2492
2493 2493 #Derivative mask
2494 2494 derPhase = numpy.nanmean(numpy.abs(phase[:,1:,:] - phase[:,:-1,:]),axis=0)
2495 2495 boolMet2 = derPhase < 0.2
2496 2496 # boolMet2 = ndimage.morphology.binary_opening(boolMet2)
2497 2497 # boolMet2 = ndimage.morphology.binary_closing(boolMet2, structure = numpy.ones((10,1)))
2498 2498 boolMet2 = ndimage.median_filter(boolMet2,size=5)
2499 2499 boolMet2 = numpy.vstack((boolMet2,numpy.full((1,nHeights), True, dtype=bool)))
2500 2500 # #Final mask
2501 2501 # boolMetFin = boolMet2
2502 2502 boolMetFin = boolMet1&boolMet2
2503 2503 # boolMetFin = ndimage.morphology.binary_dilation(boolMetFin)
2504 2504 #Creating data_param
2505 2505 coordMet = numpy.where(boolMetFin)
2506 2506
2507 2507 tmet = coordMet[0]
2508 2508 hmet = coordMet[1]
2509 2509
2510 2510 data_param = numpy.zeros((tmet.size, 6 + nPairs))
2511 2511 data_param[:,0] = utctime
2512 2512 data_param[:,1] = tmet
2513 2513 data_param[:,2] = hmet
2514 2514 data_param[:,3] = SNRm[tmet,hmet]
2515 2515 data_param[:,4] = velRad[tmet,hmet]
2516 2516 data_param[:,5] = coh[tmet,hmet]
2517 2517 data_param[:,6:] = phase[:,tmet,hmet].T
2518 2518
2519 2519 elif mode == 'DBS':
2520 2520 dataOut.groupList = numpy.arange(nChannels)
2521 2521
2522 2522 #Radial Velocities
2523 2523 phase = numpy.angle(data_acf[:,1,:,:])
2524 2524 # phase = ndimage.median_filter(numpy.angle(data_acf[:,1,:,:]), size = (1,5,1))
2525 2525 velRad = phase*lamb/(4*numpy.pi*tSamp)
2526 2526
2527 2527 #Spectral width
2528 2528 # acf1 = ndimage.median_filter(numpy.abs(data_acf[:,1,:,:]), size = (1,5,1))
2529 2529 # acf2 = ndimage.median_filter(numpy.abs(data_acf[:,2,:,:]), size = (1,5,1))
2530 2530 acf1 = data_acf[:,1,:,:]
2531 2531 acf2 = data_acf[:,2,:,:]
2532 2532
2533 2533 spcWidth = (lamb/(2*numpy.sqrt(6)*numpy.pi*tSamp))*numpy.sqrt(numpy.log(acf1/acf2))
2534 2534 # velRad = ndimage.median_filter(velRad, size = (1,5,1))
2535 2535 if allData:
2536 2536 boolMetFin = ~numpy.isnan(SNRdB)
2537 2537 else:
2538 2538 #SNR
2539 2539 boolMet1 = (SNRdB>SNRthresh) #SNR mask
2540 2540 boolMet1 = ndimage.median_filter(boolMet1, size=(1,5,5))
2541 2541
2542 2542 #Radial velocity
2543 2543 boolMet2 = numpy.abs(velRad) < 20
2544 2544 boolMet2 = ndimage.median_filter(boolMet2, (1,5,5))
2545 2545
2546 2546 #Spectral Width
2547 2547 boolMet3 = spcWidth < 30
2548 2548 boolMet3 = ndimage.median_filter(boolMet3, (1,5,5))
2549 2549 # boolMetFin = self.__erase_small(boolMet1, 10,5)
2550 2550 boolMetFin = boolMet1&boolMet2&boolMet3
2551 2551
2552 2552 #Creating data_param
2553 2553 coordMet = numpy.where(boolMetFin)
2554 2554
2555 2555 cmet = coordMet[0]
2556 2556 tmet = coordMet[1]
2557 2557 hmet = coordMet[2]
2558 2558
2559 2559 data_param = numpy.zeros((tmet.size, 7))
2560 2560 data_param[:,0] = utctime
2561 2561 data_param[:,1] = cmet
2562 2562 data_param[:,2] = tmet
2563 2563 data_param[:,3] = hmet
2564 2564 data_param[:,4] = SNR[cmet,tmet,hmet].T
2565 2565 data_param[:,5] = velRad[cmet,tmet,hmet].T
2566 2566 data_param[:,6] = spcWidth[cmet,tmet,hmet].T
2567 2567
2568 2568 # self.dataOut.data_param = data_int
2569 2569 if len(data_param) == 0:
2570 2570 dataOut.flagNoData = True
2571 2571 else:
2572 2572 dataOut.data_param = data_param
2573 2573
2574 2574 def __erase_small(self, binArray, threshX, threshY):
2575 2575 labarray, numfeat = ndimage.measurements.label(binArray)
2576 2576 binArray1 = numpy.copy(binArray)
2577 2577
2578 2578 for i in range(1,numfeat + 1):
2579 2579 auxBin = (labarray==i)
2580 2580 auxSize = auxBin.sum()
2581 2581
2582 2582 x,y = numpy.where(auxBin)
2583 2583 widthX = x.max() - x.min()
2584 2584 widthY = y.max() - y.min()
2585 2585
2586 2586 #width X: 3 seg -> 12.5*3
2587 2587 #width Y:
2588 2588
2589 2589 if (auxSize < 50) or (widthX < threshX) or (widthY < threshY):
2590 2590 binArray1[auxBin] = False
2591 2591
2592 2592 return binArray1
2593 2593
2594 2594 #--------------- Specular Meteor ----------------
2595 2595
2596 2596 class SMDetection(Operation):
2597 2597 '''
2598 2598 Function DetectMeteors()
2599 2599 Project developed with paper:
2600 2600 HOLDSWORTH ET AL. 2004
2601 2601
2602 2602 Input:
2603 2603 self.dataOut.data_pre
2604 2604
2605 2605 centerReceiverIndex: From the channels, which is the center receiver
2606 2606
2607 2607 hei_ref: Height reference for the Beacon signal extraction
2608 2608 tauindex:
2609 2609 predefinedPhaseShifts: Predefined phase offset for the voltge signals
2610 2610
2611 2611 cohDetection: Whether to user Coherent detection or not
2612 2612 cohDet_timeStep: Coherent Detection calculation time step
2613 2613 cohDet_thresh: Coherent Detection phase threshold to correct phases
2614 2614
2615 2615 noise_timeStep: Noise calculation time step
2616 2616 noise_multiple: Noise multiple to define signal threshold
2617 2617
2618 2618 multDet_timeLimit: Multiple Detection Removal time limit in seconds
2619 2619 multDet_rangeLimit: Multiple Detection Removal range limit in km
2620 2620
2621 2621 phaseThresh: Maximum phase difference between receiver to be consider a meteor
2622 2622 SNRThresh: Minimum SNR threshold of the meteor signal to be consider a meteor
2623 2623
2624 2624 hmin: Minimum Height of the meteor to use it in the further wind estimations
2625 2625 hmax: Maximum Height of the meteor to use it in the further wind estimations
2626 2626 azimuth: Azimuth angle correction
2627 2627
2628 2628 Affected:
2629 2629 self.dataOut.data_param
2630 2630
2631 2631 Rejection Criteria (Errors):
2632 2632 0: No error; analysis OK
2633 2633 1: SNR < SNR threshold
2634 2634 2: angle of arrival (AOA) ambiguously determined
2635 2635 3: AOA estimate not feasible
2636 2636 4: Large difference in AOAs obtained from different antenna baselines
2637 2637 5: echo at start or end of time series
2638 2638 6: echo less than 5 examples long; too short for analysis
2639 2639 7: echo rise exceeds 0.3s
2640 2640 8: echo decay time less than twice rise time
2641 2641 9: large power level before echo
2642 2642 10: large power level after echo
2643 2643 11: poor fit to amplitude for estimation of decay time
2644 2644 12: poor fit to CCF phase variation for estimation of radial drift velocity
2645 2645 13: height unresolvable echo: not valid height within 70 to 110 km
2646 2646 14: height ambiguous echo: more then one possible height within 70 to 110 km
2647 2647 15: radial drift velocity or projected horizontal velocity exceeds 200 m/s
2648 2648 16: oscilatory echo, indicating event most likely not an underdense echo
2649 2649
2650 2650 17: phase difference in meteor Reestimation
2651 2651
2652 2652 Data Storage:
2653 2653 Meteors for Wind Estimation (8):
2654 2654 Utc Time | Range Height
2655 2655 Azimuth Zenith errorCosDir
2656 2656 VelRad errorVelRad
2657 2657 Phase0 Phase1 Phase2 Phase3
2658 2658 TypeError
2659 2659
2660 2660 '''
2661 2661
2662 2662 def run(self, dataOut, hei_ref = None, tauindex = 0,
2663 2663 phaseOffsets = None,
2664 2664 cohDetection = False, cohDet_timeStep = 1, cohDet_thresh = 25,
2665 2665 noise_timeStep = 4, noise_multiple = 4,
2666 2666 multDet_timeLimit = 1, multDet_rangeLimit = 3,
2667 2667 phaseThresh = 20, SNRThresh = 5,
2668 2668 hmin = 50, hmax=150, azimuth = 0,
2669 2669 channelPositions = None) :
2670 2670
2671 2671
2672 2672 #Getting Pairslist
2673 2673 if channelPositions is None:
2674 2674 # channelPositions = [(2.5,0), (0,2.5), (0,0), (0,4.5), (-2,0)] #T
2675 2675 channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)] #Estrella
2676 2676 meteorOps = SMOperations()
2677 2677 pairslist0, distances = meteorOps.getPhasePairs(channelPositions)
2678 2678 heiRang = dataOut.heightList
2679 2679 #Get Beacon signal - No Beacon signal anymore
2680 2680 # newheis = numpy.where(self.dataOut.heightList>self.dataOut.radarControllerHeaderObj.Taus[tauindex])
2681 2681 #
2682 2682 # if hei_ref != None:
2683 2683 # newheis = numpy.where(self.dataOut.heightList>hei_ref)
2684 2684 #
2685 2685
2686 2686
2687 2687 #****************REMOVING HARDWARE PHASE DIFFERENCES***************
2688 2688 # see if the user put in pre defined phase shifts
2689 2689 voltsPShift = dataOut.data_pre.copy()
2690 2690
2691 2691 # if predefinedPhaseShifts != None:
2692 2692 # hardwarePhaseShifts = numpy.array(predefinedPhaseShifts)*numpy.pi/180
2693 2693 #
2694 2694 # # elif beaconPhaseShifts:
2695 2695 # # #get hardware phase shifts using beacon signal
2696 2696 # # hardwarePhaseShifts = self.__getHardwarePhaseDiff(self.dataOut.data_pre, pairslist, newheis, 10)
2697 2697 # # hardwarePhaseShifts = numpy.insert(hardwarePhaseShifts,centerReceiverIndex,0)
2698 2698 #
2699 2699 # else:
2700 2700 # hardwarePhaseShifts = numpy.zeros(5)
2701 2701 #
2702 2702 # voltsPShift = numpy.zeros((self.dataOut.data_pre.shape[0],self.dataOut.data_pre.shape[1],self.dataOut.data_pre.shape[2]), dtype = 'complex')
2703 2703 # for i in range(self.dataOut.data_pre.shape[0]):
2704 2704 # voltsPShift[i,:,:] = self.__shiftPhase(self.dataOut.data_pre[i,:,:], hardwarePhaseShifts[i])
2705 2705
2706 2706 #******************END OF REMOVING HARDWARE PHASE DIFFERENCES*********
2707 2707
2708 2708 #Remove DC
2709 2709 voltsDC = numpy.mean(voltsPShift,1)
2710 2710 voltsDC = numpy.mean(voltsDC,1)
2711 2711 for i in range(voltsDC.shape[0]):
2712 2712 voltsPShift[i] = voltsPShift[i] - voltsDC[i]
2713 2713
2714 2714 #Don't considerate last heights, theyre used to calculate Hardware Phase Shift
2715 2715 # voltsPShift = voltsPShift[:,:,:newheis[0][0]]
2716 2716
2717 2717 #************ FIND POWER OF DATA W/COH OR NON COH DETECTION (3.4) **********
2718 2718 #Coherent Detection
2719 2719 if cohDetection:
2720 2720 #use coherent detection to get the net power
2721 2721 cohDet_thresh = cohDet_thresh*numpy.pi/180
2722 2722 voltsPShift = self.__coherentDetection(voltsPShift, cohDet_timeStep, dataOut.timeInterval, pairslist0, cohDet_thresh)
2723 2723
2724 2724 #Non-coherent detection!
2725 2725 powerNet = numpy.nansum(numpy.abs(voltsPShift[:,:,:])**2,0)
2726 2726 #********** END OF COH/NON-COH POWER CALCULATION**********************
2727 2727
2728 2728 #********** FIND THE NOISE LEVEL AND POSSIBLE METEORS ****************
2729 2729 #Get noise
2730 2730 noise, noise1 = self.__getNoise(powerNet, noise_timeStep, dataOut.timeInterval)
2731 2731 # noise = self.getNoise1(powerNet, noise_timeStep, self.dataOut.timeInterval)
2732 2732 #Get signal threshold
2733 2733 signalThresh = noise_multiple*noise
2734 2734 #Meteor echoes detection
2735 2735 listMeteors = self.__findMeteors(powerNet, signalThresh)
2736 2736 #******* END OF NOISE LEVEL AND POSSIBLE METEORS CACULATION **********
2737 2737
2738 2738 #************** REMOVE MULTIPLE DETECTIONS (3.5) ***************************
2739 2739 #Parameters
2740 2740 heiRange = dataOut.heightList
2741 2741 rangeInterval = heiRange[1] - heiRange[0]
2742 2742 rangeLimit = multDet_rangeLimit/rangeInterval
2743 2743 timeLimit = multDet_timeLimit/dataOut.timeInterval
2744 2744 #Multiple detection removals
2745 2745 listMeteors1 = self.__removeMultipleDetections(listMeteors, rangeLimit, timeLimit)
2746 2746 #************ END OF REMOVE MULTIPLE DETECTIONS **********************
2747 2747
2748 2748 #********************* METEOR REESTIMATION (3.7, 3.8, 3.9, 3.10) ********************
2749 2749 #Parameters
2750 2750 phaseThresh = phaseThresh*numpy.pi/180
2751 2751 thresh = [phaseThresh, noise_multiple, SNRThresh]
2752 2752 #Meteor reestimation (Errors N 1, 6, 12, 17)
2753 2753 listMeteors2, listMeteorsPower, listMeteorsVolts = self.__meteorReestimation(listMeteors1, voltsPShift, pairslist0, thresh, noise, dataOut.timeInterval, dataOut.frequency)
2754 2754 # listMeteors2, listMeteorsPower, listMeteorsVolts = self.meteorReestimation3(listMeteors2, listMeteorsPower, listMeteorsVolts, voltsPShift, pairslist, thresh, noise)
2755 2755 #Estimation of decay times (Errors N 7, 8, 11)
2756 2756 listMeteors3 = self.__estimateDecayTime(listMeteors2, listMeteorsPower, dataOut.timeInterval, dataOut.frequency)
2757 2757 #******************* END OF METEOR REESTIMATION *******************
2758 2758
2759 2759 #********************* METEOR PARAMETERS CALCULATION (3.11, 3.12, 3.13) **************************
2760 2760 #Calculating Radial Velocity (Error N 15)
2761 2761 radialStdThresh = 10
2762 2762 listMeteors4 = self.__getRadialVelocity(listMeteors3, listMeteorsVolts, radialStdThresh, pairslist0, dataOut.timeInterval)
2763 2763
2764 2764 if len(listMeteors4) > 0:
2765 2765 #Setting New Array
2766 2766 date = dataOut.utctime
2767 2767 arrayParameters = self.__setNewArrays(listMeteors4, date, heiRang)
2768 2768
2769 2769 #Correcting phase offset
2770 2770 if phaseOffsets != None:
2771 2771 phaseOffsets = numpy.array(phaseOffsets)*numpy.pi/180
2772 2772 arrayParameters[:,8:12] = numpy.unwrap(arrayParameters[:,8:12] + phaseOffsets)
2773 2773
2774 2774 #Second Pairslist
2775 2775 pairsList = []
2776 2776 pairx = (0,1)
2777 2777 pairy = (2,3)
2778 2778 pairsList.append(pairx)
2779 2779 pairsList.append(pairy)
2780 2780
2781 2781 jph = numpy.array([0,0,0,0])
2782 2782 h = (hmin,hmax)
2783 2783 arrayParameters = meteorOps.getMeteorParams(arrayParameters, azimuth, h, pairsList, distances, jph)
2784 2784
2785 2785 # #Calculate AOA (Error N 3, 4)
2786 2786 # #JONES ET AL. 1998
2787 2787 # error = arrayParameters[:,-1]
2788 2788 # AOAthresh = numpy.pi/8
2789 2789 # phases = -arrayParameters[:,9:13]
2790 2790 # arrayParameters[:,4:7], arrayParameters[:,-1] = meteorOps.getAOA(phases, pairsList, error, AOAthresh, azimuth)
2791 2791 #
2792 2792 # #Calculate Heights (Error N 13 and 14)
2793 2793 # error = arrayParameters[:,-1]
2794 2794 # Ranges = arrayParameters[:,2]
2795 2795 # zenith = arrayParameters[:,5]
2796 2796 # arrayParameters[:,3], arrayParameters[:,-1] = meteorOps.getHeights(Ranges, zenith, error, hmin, hmax)
2797 2797 # error = arrayParameters[:,-1]
2798 2798 #********************* END OF PARAMETERS CALCULATION **************************
2799 2799
2800 2800 #***************************+ PASS DATA TO NEXT STEP **********************
2801 2801 # arrayFinal = arrayParameters.reshape((1,arrayParameters.shape[0],arrayParameters.shape[1]))
2802 2802 dataOut.data_param = arrayParameters
2803 2803
2804 2804 if arrayParameters is None:
2805 2805 dataOut.flagNoData = True
2806 2806 else:
2807 2807 dataOut.flagNoData = True
2808 2808
2809 2809 return
2810 2810
2811 2811 def __getHardwarePhaseDiff(self, voltage0, pairslist, newheis, n):
2812 2812
2813 2813 minIndex = min(newheis[0])
2814 2814 maxIndex = max(newheis[0])
2815 2815
2816 2816 voltage = voltage0[:,:,minIndex:maxIndex+1]
2817 2817 nLength = voltage.shape[1]/n
2818 2818 nMin = 0
2819 2819 nMax = 0
2820 2820 phaseOffset = numpy.zeros((len(pairslist),n))
2821 2821
2822 2822 for i in range(n):
2823 2823 nMax += nLength
2824 2824 phaseCCF = -numpy.angle(self.__calculateCCF(voltage[:,nMin:nMax,:], pairslist, [0]))
2825 2825 phaseCCF = numpy.mean(phaseCCF, axis = 2)
2826 2826 phaseOffset[:,i] = phaseCCF.transpose()
2827 2827 nMin = nMax
2828 2828 # phaseDiff, phaseArrival = self.estimatePhaseDifference(voltage, pairslist)
2829 2829
2830 2830 #Remove Outliers
2831 2831 factor = 2
2832 2832 wt = phaseOffset - signal.medfilt(phaseOffset,(1,5))
2833 2833 dw = numpy.std(wt,axis = 1)
2834 2834 dw = dw.reshape((dw.size,1))
2835 2835 ind = numpy.where(numpy.logical_or(wt>dw*factor,wt<-dw*factor))
2836 2836 phaseOffset[ind] = numpy.nan
2837 2837 phaseOffset = stats.nanmean(phaseOffset, axis=1)
2838 2838
2839 2839 return phaseOffset
2840 2840
2841 2841 def __shiftPhase(self, data, phaseShift):
2842 2842 #this will shift the phase of a complex number
2843 2843 dataShifted = numpy.abs(data) * numpy.exp((numpy.angle(data)+phaseShift)*1j)
2844 2844 return dataShifted
2845 2845
2846 2846 def __estimatePhaseDifference(self, array, pairslist):
2847 2847 nChannel = array.shape[0]
2848 2848 nHeights = array.shape[2]
2849 2849 numPairs = len(pairslist)
2850 2850 # phaseCCF = numpy.zeros((nChannel, 5, nHeights))
2851 2851 phaseCCF = numpy.angle(self.__calculateCCF(array, pairslist, [-2,-1,0,1,2]))
2852 2852
2853 2853 #Correct phases
2854 2854 derPhaseCCF = phaseCCF[:,1:,:] - phaseCCF[:,0:-1,:]
2855 2855 indDer = numpy.where(numpy.abs(derPhaseCCF) > numpy.pi)
2856 2856
2857 2857 if indDer[0].shape[0] > 0:
2858 2858 for i in range(indDer[0].shape[0]):
2859 2859 signo = -numpy.sign(derPhaseCCF[indDer[0][i],indDer[1][i],indDer[2][i]])
2860 2860 phaseCCF[indDer[0][i],indDer[1][i]+1:,:] += signo*2*numpy.pi
2861 2861
2862 2862 # for j in range(numSides):
2863 2863 # phaseCCFAux = self.calculateCCF(arrayCenter, arraySides[j,:,:], [-2,1,0,1,2])
2864 2864 # phaseCCF[j,:,:] = numpy.angle(phaseCCFAux)
2865 2865 #
2866 2866 #Linear
2867 2867 phaseInt = numpy.zeros((numPairs,1))
2868 2868 angAllCCF = phaseCCF[:,[0,1,3,4],0]
2869 2869 for j in range(numPairs):
2870 2870 fit = stats.linregress([-2,-1,1,2],angAllCCF[j,:])
2871 2871 phaseInt[j] = fit[1]
2872 2872 #Phase Differences
2873 2873 phaseDiff = phaseInt - phaseCCF[:,2,:]
2874 2874 phaseArrival = phaseInt.reshape(phaseInt.size)
2875 2875
2876 2876 #Dealias
2877 2877 phaseArrival = numpy.angle(numpy.exp(1j*phaseArrival))
2878 2878 # indAlias = numpy.where(phaseArrival > numpy.pi)
2879 2879 # phaseArrival[indAlias] -= 2*numpy.pi
2880 2880 # indAlias = numpy.where(phaseArrival < -numpy.pi)
2881 2881 # phaseArrival[indAlias] += 2*numpy.pi
2882 2882
2883 2883 return phaseDiff, phaseArrival
2884 2884
2885 2885 def __coherentDetection(self, volts, timeSegment, timeInterval, pairslist, thresh):
2886 2886 #this function will run the coherent detection used in Holdworth et al. 2004 and return the net power
2887 2887 #find the phase shifts of each channel over 1 second intervals
2888 2888 #only look at ranges below the beacon signal
2889 2889 numProfPerBlock = numpy.ceil(timeSegment/timeInterval)
2890 2890 numBlocks = int(volts.shape[1]/numProfPerBlock)
2891 2891 numHeights = volts.shape[2]
2892 2892 nChannel = volts.shape[0]
2893 2893 voltsCohDet = volts.copy()
2894 2894
2895 2895 pairsarray = numpy.array(pairslist)
2896 2896 indSides = pairsarray[:,1]
2897 2897 # indSides = numpy.array(range(nChannel))
2898 2898 # indSides = numpy.delete(indSides, indCenter)
2899 2899 #
2900 2900 # listCenter = numpy.array_split(volts[indCenter,:,:], numBlocks, 0)
2901 2901 listBlocks = numpy.array_split(volts, numBlocks, 1)
2902 2902
2903 2903 startInd = 0
2904 2904 endInd = 0
2905 2905
2906 2906 for i in range(numBlocks):
2907 2907 startInd = endInd
2908 2908 endInd = endInd + listBlocks[i].shape[1]
2909 2909
2910 2910 arrayBlock = listBlocks[i]
2911 2911 # arrayBlockCenter = listCenter[i]
2912 2912
2913 2913 #Estimate the Phase Difference
2914 2914 phaseDiff, aux = self.__estimatePhaseDifference(arrayBlock, pairslist)
2915 2915 #Phase Difference RMS
2916 2916 arrayPhaseRMS = numpy.abs(phaseDiff)
2917 2917 phaseRMSaux = numpy.sum(arrayPhaseRMS < thresh,0)
2918 2918 indPhase = numpy.where(phaseRMSaux==4)
2919 2919 #Shifting
2920 2920 if indPhase[0].shape[0] > 0:
2921 2921 for j in range(indSides.size):
2922 2922 arrayBlock[indSides[j],:,indPhase] = self.__shiftPhase(arrayBlock[indSides[j],:,indPhase], phaseDiff[j,indPhase].transpose())
2923 2923 voltsCohDet[:,startInd:endInd,:] = arrayBlock
2924 2924
2925 2925 return voltsCohDet
2926 2926
2927 2927 def __calculateCCF(self, volts, pairslist ,laglist):
2928 2928
2929 2929 nHeights = volts.shape[2]
2930 2930 nPoints = volts.shape[1]
2931 2931 voltsCCF = numpy.zeros((len(pairslist), len(laglist), nHeights),dtype = 'complex')
2932 2932
2933 2933 for i in range(len(pairslist)):
2934 2934 volts1 = volts[pairslist[i][0]]
2935 2935 volts2 = volts[pairslist[i][1]]
2936 2936
2937 2937 for t in range(len(laglist)):
2938 2938 idxT = laglist[t]
2939 2939 if idxT >= 0:
2940 2940 vStacked = numpy.vstack((volts2[idxT:,:],
2941 2941 numpy.zeros((idxT, nHeights),dtype='complex')))
2942 2942 else:
2943 2943 vStacked = numpy.vstack((numpy.zeros((-idxT, nHeights),dtype='complex'),
2944 2944 volts2[:(nPoints + idxT),:]))
2945 2945 voltsCCF[i,t,:] = numpy.sum((numpy.conjugate(volts1)*vStacked),axis=0)
2946 2946
2947 2947 vStacked = None
2948 2948 return voltsCCF
2949 2949
2950 2950 def __getNoise(self, power, timeSegment, timeInterval):
2951 2951 numProfPerBlock = numpy.ceil(timeSegment/timeInterval)
2952 2952 numBlocks = int(power.shape[0]/numProfPerBlock)
2953 2953 numHeights = power.shape[1]
2954 2954
2955 2955 listPower = numpy.array_split(power, numBlocks, 0)
2956 2956 noise = numpy.zeros((power.shape[0], power.shape[1]))
2957 2957 noise1 = numpy.zeros((power.shape[0], power.shape[1]))
2958 2958
2959 2959 startInd = 0
2960 2960 endInd = 0
2961 2961
2962 2962 for i in range(numBlocks): #split por canal
2963 2963 startInd = endInd
2964 2964 endInd = endInd + listPower[i].shape[0]
2965 2965
2966 2966 arrayBlock = listPower[i]
2967 2967 noiseAux = numpy.mean(arrayBlock, 0)
2968 2968 # noiseAux = numpy.median(noiseAux)
2969 2969 # noiseAux = numpy.mean(arrayBlock)
2970 2970 noise[startInd:endInd,:] = noise[startInd:endInd,:] + noiseAux
2971 2971
2972 2972 noiseAux1 = numpy.mean(arrayBlock)
2973 2973 noise1[startInd:endInd,:] = noise1[startInd:endInd,:] + noiseAux1
2974 2974
2975 2975 return noise, noise1
2976 2976
2977 2977 def __findMeteors(self, power, thresh):
2978 2978 nProf = power.shape[0]
2979 2979 nHeights = power.shape[1]
2980 2980 listMeteors = []
2981 2981
2982 2982 for i in range(nHeights):
2983 2983 powerAux = power[:,i]
2984 2984 threshAux = thresh[:,i]
2985 2985
2986 2986 indUPthresh = numpy.where(powerAux > threshAux)[0]
2987 2987 indDNthresh = numpy.where(powerAux <= threshAux)[0]
2988 2988
2989 2989 j = 0
2990 2990
2991 2991 while (j < indUPthresh.size - 2):
2992 2992 if (indUPthresh[j + 2] == indUPthresh[j] + 2):
2993 2993 indDNAux = numpy.where(indDNthresh > indUPthresh[j])
2994 2994 indDNthresh = indDNthresh[indDNAux]
2995 2995
2996 2996 if (indDNthresh.size > 0):
2997 2997 indEnd = indDNthresh[0] - 1
2998 2998 indInit = indUPthresh[j]
2999 2999
3000 3000 meteor = powerAux[indInit:indEnd + 1]
3001 3001 indPeak = meteor.argmax() + indInit
3002 3002 FLA = sum(numpy.conj(meteor)*numpy.hstack((meteor[1:],0)))
3003 3003
3004 3004 listMeteors.append(numpy.array([i,indInit,indPeak,indEnd,FLA])) #CHEQUEAR!!!!!
3005 3005 j = numpy.where(indUPthresh == indEnd)[0] + 1
3006 3006 else: j+=1
3007 3007 else: j+=1
3008 3008
3009 3009 return listMeteors
3010 3010
3011 3011 def __removeMultipleDetections(self,listMeteors, rangeLimit, timeLimit):
3012 3012
3013 3013 arrayMeteors = numpy.asarray(listMeteors)
3014 3014 listMeteors1 = []
3015 3015
3016 3016 while arrayMeteors.shape[0] > 0:
3017 3017 FLAs = arrayMeteors[:,4]
3018 3018 maxFLA = FLAs.argmax()
3019 3019 listMeteors1.append(arrayMeteors[maxFLA,:])
3020 3020
3021 3021 MeteorInitTime = arrayMeteors[maxFLA,1]
3022 3022 MeteorEndTime = arrayMeteors[maxFLA,3]
3023 3023 MeteorHeight = arrayMeteors[maxFLA,0]
3024 3024
3025 3025 #Check neighborhood
3026 3026 maxHeightIndex = MeteorHeight + rangeLimit
3027 3027 minHeightIndex = MeteorHeight - rangeLimit
3028 3028 minTimeIndex = MeteorInitTime - timeLimit
3029 3029 maxTimeIndex = MeteorEndTime + timeLimit
3030 3030
3031 3031 #Check Heights
3032 3032 indHeight = numpy.logical_and(arrayMeteors[:,0] >= minHeightIndex, arrayMeteors[:,0] <= maxHeightIndex)
3033 3033 indTime = numpy.logical_and(arrayMeteors[:,3] >= minTimeIndex, arrayMeteors[:,1] <= maxTimeIndex)
3034 3034 indBoth = numpy.where(numpy.logical_and(indTime,indHeight))
3035 3035
3036 3036 arrayMeteors = numpy.delete(arrayMeteors, indBoth, axis = 0)
3037 3037
3038 3038 return listMeteors1
3039 3039
3040 3040 def __meteorReestimation(self, listMeteors, volts, pairslist, thresh, noise, timeInterval,frequency):
3041 3041 numHeights = volts.shape[2]
3042 3042 nChannel = volts.shape[0]
3043 3043
3044 3044 thresholdPhase = thresh[0]
3045 3045 thresholdNoise = thresh[1]
3046 3046 thresholdDB = float(thresh[2])
3047 3047
3048 3048 thresholdDB1 = 10**(thresholdDB/10)
3049 3049 pairsarray = numpy.array(pairslist)
3050 3050 indSides = pairsarray[:,1]
3051 3051
3052 3052 pairslist1 = list(pairslist)
3053 3053 pairslist1.append((0,1))
3054 3054 pairslist1.append((3,4))
3055 3055
3056 3056 listMeteors1 = []
3057 3057 listPowerSeries = []
3058 3058 listVoltageSeries = []
3059 3059 #volts has the war data
3060 3060
3061 3061 if frequency == 30e6:
3062 3062 timeLag = 45*10**-3
3063 3063 else:
3064 3064 timeLag = 15*10**-3
3065 3065 lag = numpy.ceil(timeLag/timeInterval)
3066 3066
3067 3067 for i in range(len(listMeteors)):
3068 3068
3069 3069 ###################### 3.6 - 3.7 PARAMETERS REESTIMATION #########################
3070 3070 meteorAux = numpy.zeros(16)
3071 3071
3072 3072 #Loading meteor Data (mHeight, mStart, mPeak, mEnd)
3073 3073 mHeight = listMeteors[i][0]
3074 3074 mStart = listMeteors[i][1]
3075 3075 mPeak = listMeteors[i][2]
3076 3076 mEnd = listMeteors[i][3]
3077 3077
3078 3078 #get the volt data between the start and end times of the meteor
3079 3079 meteorVolts = volts[:,mStart:mEnd+1,mHeight]
3080 3080 meteorVolts = meteorVolts.reshape(meteorVolts.shape[0], meteorVolts.shape[1], 1)
3081 3081
3082 3082 #3.6. Phase Difference estimation
3083 3083 phaseDiff, aux = self.__estimatePhaseDifference(meteorVolts, pairslist)
3084 3084
3085 3085 #3.7. Phase difference removal & meteor start, peak and end times reestimated
3086 3086 #meteorVolts0.- all Channels, all Profiles
3087 3087 meteorVolts0 = volts[:,:,mHeight]
3088 3088 meteorThresh = noise[:,mHeight]*thresholdNoise
3089 3089 meteorNoise = noise[:,mHeight]
3090 3090 meteorVolts0[indSides,:] = self.__shiftPhase(meteorVolts0[indSides,:], phaseDiff) #Phase Shifting
3091 3091 powerNet0 = numpy.nansum(numpy.abs(meteorVolts0)**2, axis = 0) #Power
3092 3092
3093 3093 #Times reestimation
3094 3094 mStart1 = numpy.where(powerNet0[:mPeak] < meteorThresh[:mPeak])[0]
3095 3095 if mStart1.size > 0:
3096 3096 mStart1 = mStart1[-1] + 1
3097 3097
3098 3098 else:
3099 3099 mStart1 = mPeak
3100 3100
3101 3101 mEnd1 = numpy.where(powerNet0[mPeak:] < meteorThresh[mPeak:])[0][0] + mPeak - 1
3102 3102 mEndDecayTime1 = numpy.where(powerNet0[mPeak:] < meteorNoise[mPeak:])[0]
3103 3103 if mEndDecayTime1.size == 0:
3104 3104 mEndDecayTime1 = powerNet0.size
3105 3105 else:
3106 3106 mEndDecayTime1 = mEndDecayTime1[0] + mPeak - 1
3107 3107 # mPeak1 = meteorVolts0[mStart1:mEnd1 + 1].argmax()
3108 3108
3109 3109 #meteorVolts1.- all Channels, from start to end
3110 3110 meteorVolts1 = meteorVolts0[:,mStart1:mEnd1 + 1]
3111 3111 meteorVolts2 = meteorVolts0[:,mPeak + lag:mEnd1 + 1]
3112 3112 if meteorVolts2.shape[1] == 0:
3113 3113 meteorVolts2 = meteorVolts0[:,mPeak:mEnd1 + 1]
3114 3114 meteorVolts1 = meteorVolts1.reshape(meteorVolts1.shape[0], meteorVolts1.shape[1], 1)
3115 3115 meteorVolts2 = meteorVolts2.reshape(meteorVolts2.shape[0], meteorVolts2.shape[1], 1)
3116 3116 ##################### END PARAMETERS REESTIMATION #########################
3117 3117
3118 3118 ##################### 3.8 PHASE DIFFERENCE REESTIMATION ########################
3119 3119 # if mEnd1 - mStart1 > 4: #Error Number 6: echo less than 5 samples long; too short for analysis
3120 3120 if meteorVolts2.shape[1] > 0:
3121 3121 #Phase Difference re-estimation
3122 3122 phaseDiff1, phaseDiffint = self.__estimatePhaseDifference(meteorVolts2, pairslist1) #Phase Difference Estimation
3123 3123 # phaseDiff1, phaseDiffint = self.estimatePhaseDifference(meteorVolts2, pairslist)
3124 3124 meteorVolts2 = meteorVolts2.reshape(meteorVolts2.shape[0], meteorVolts2.shape[1])
3125 3125 phaseDiff11 = numpy.reshape(phaseDiff1, (phaseDiff1.shape[0],1))
3126 3126 meteorVolts2[indSides,:] = self.__shiftPhase(meteorVolts2[indSides,:], phaseDiff11[0:4]) #Phase Shifting
3127 3127
3128 3128 #Phase Difference RMS
3129 3129 phaseRMS1 = numpy.sqrt(numpy.mean(numpy.square(phaseDiff1)))
3130 3130 powerNet1 = numpy.nansum(numpy.abs(meteorVolts1[:,:])**2,0)
3131 3131 #Data from Meteor
3132 3132 mPeak1 = powerNet1.argmax() + mStart1
3133 3133 mPeakPower1 = powerNet1.max()
3134 3134 noiseAux = sum(noise[mStart1:mEnd1 + 1,mHeight])
3135 3135 mSNR1 = (sum(powerNet1)-noiseAux)/noiseAux
3136 3136 Meteor1 = numpy.array([mHeight, mStart1, mPeak1, mEnd1, mPeakPower1, mSNR1, phaseRMS1])
3137 3137 Meteor1 = numpy.hstack((Meteor1,phaseDiffint))
3138 3138 PowerSeries = powerNet0[mStart1:mEndDecayTime1 + 1]
3139 3139 #Vectorize
3140 3140 meteorAux[0:7] = [mHeight, mStart1, mPeak1, mEnd1, mPeakPower1, mSNR1, phaseRMS1]
3141 3141 meteorAux[7:11] = phaseDiffint[0:4]
3142 3142
3143 3143 #Rejection Criterions
3144 3144 if phaseRMS1 > thresholdPhase: #Error Number 17: Phase variation
3145 3145 meteorAux[-1] = 17
3146 3146 elif mSNR1 < thresholdDB1: #Error Number 1: SNR < threshold dB
3147 3147 meteorAux[-1] = 1
3148 3148
3149 3149
3150 3150 else:
3151 3151 meteorAux[0:4] = [mHeight, mStart, mPeak, mEnd]
3152 3152 meteorAux[-1] = 6 #Error Number 6: echo less than 5 samples long; too short for analysis
3153 3153 PowerSeries = 0
3154 3154
3155 3155 listMeteors1.append(meteorAux)
3156 3156 listPowerSeries.append(PowerSeries)
3157 3157 listVoltageSeries.append(meteorVolts1)
3158 3158
3159 3159 return listMeteors1, listPowerSeries, listVoltageSeries
3160 3160
3161 3161 def __estimateDecayTime(self, listMeteors, listPower, timeInterval, frequency):
3162 3162
3163 3163 threshError = 10
3164 3164 #Depending if it is 30 or 50 MHz
3165 3165 if frequency == 30e6:
3166 3166 timeLag = 45*10**-3
3167 3167 else:
3168 3168 timeLag = 15*10**-3
3169 3169 lag = numpy.ceil(timeLag/timeInterval)
3170 3170
3171 3171 listMeteors1 = []
3172 3172
3173 3173 for i in range(len(listMeteors)):
3174 3174 meteorPower = listPower[i]
3175 3175 meteorAux = listMeteors[i]
3176 3176
3177 3177 if meteorAux[-1] == 0:
3178 3178
3179 3179 try:
3180 3180 indmax = meteorPower.argmax()
3181 3181 indlag = indmax + lag
3182 3182
3183 3183 y = meteorPower[indlag:]
3184 3184 x = numpy.arange(0, y.size)*timeLag
3185 3185
3186 3186 #first guess
3187 3187 a = y[0]
3188 3188 tau = timeLag
3189 3189 #exponential fit
3190 3190 popt, pcov = optimize.curve_fit(self.__exponential_function, x, y, p0 = [a, tau])
3191 3191 y1 = self.__exponential_function(x, *popt)
3192 3192 #error estimation
3193 3193 error = sum((y - y1)**2)/(numpy.var(y)*(y.size - popt.size))
3194 3194
3195 3195 decayTime = popt[1]
3196 3196 riseTime = indmax*timeInterval
3197 3197 meteorAux[11:13] = [decayTime, error]
3198 3198
3199 3199 #Table items 7, 8 and 11
3200 3200 if (riseTime > 0.3): #Number 7: Echo rise exceeds 0.3s
3201 3201 meteorAux[-1] = 7
3202 3202 elif (decayTime < 2*riseTime) : #Number 8: Echo decay time less than than twice rise time
3203 3203 meteorAux[-1] = 8
3204 3204 if (error > threshError): #Number 11: Poor fit to amplitude for estimation of decay time
3205 3205 meteorAux[-1] = 11
3206 3206
3207 3207
3208 3208 except:
3209 3209 meteorAux[-1] = 11
3210 3210
3211 3211
3212 3212 listMeteors1.append(meteorAux)
3213 3213
3214 3214 return listMeteors1
3215 3215
3216 3216 #Exponential Function
3217 3217
3218 3218 def __exponential_function(self, x, a, tau):
3219 3219 y = a*numpy.exp(-x/tau)
3220 3220 return y
3221 3221
3222 3222 def __getRadialVelocity(self, listMeteors, listVolts, radialStdThresh, pairslist, timeInterval):
3223 3223
3224 3224 pairslist1 = list(pairslist)
3225 3225 pairslist1.append((0,1))
3226 3226 pairslist1.append((3,4))
3227 3227 numPairs = len(pairslist1)
3228 3228 #Time Lag
3229 3229 timeLag = 45*10**-3
3230 3230 c = 3e8
3231 3231 lag = numpy.ceil(timeLag/timeInterval)
3232 3232 freq = 30e6
3233 3233
3234 3234 listMeteors1 = []
3235 3235
3236 3236 for i in range(len(listMeteors)):
3237 3237 meteorAux = listMeteors[i]
3238 3238 if meteorAux[-1] == 0:
3239 3239 mStart = listMeteors[i][1]
3240 3240 mPeak = listMeteors[i][2]
3241 3241 mLag = mPeak - mStart + lag
3242 3242
3243 3243 #get the volt data between the start and end times of the meteor
3244 3244 meteorVolts = listVolts[i]
3245 3245 meteorVolts = meteorVolts.reshape(meteorVolts.shape[0], meteorVolts.shape[1], 1)
3246 3246
3247 3247 #Get CCF
3248 3248 allCCFs = self.__calculateCCF(meteorVolts, pairslist1, [-2,-1,0,1,2])
3249 3249
3250 3250 #Method 2
3251 3251 slopes = numpy.zeros(numPairs)
3252 3252 time = numpy.array([-2,-1,1,2])*timeInterval
3253 3253 angAllCCF = numpy.angle(allCCFs[:,[0,1,3,4],0])
3254 3254
3255 3255 #Correct phases
3256 3256 derPhaseCCF = angAllCCF[:,1:] - angAllCCF[:,0:-1]
3257 3257 indDer = numpy.where(numpy.abs(derPhaseCCF) > numpy.pi)
3258 3258
3259 3259 if indDer[0].shape[0] > 0:
3260 3260 for i in range(indDer[0].shape[0]):
3261 3261 signo = -numpy.sign(derPhaseCCF[indDer[0][i],indDer[1][i]])
3262 3262 angAllCCF[indDer[0][i],indDer[1][i]+1:] += signo*2*numpy.pi
3263 3263
3264 3264 # fit = scipy.stats.linregress(numpy.array([-2,-1,1,2])*timeInterval, numpy.array([phaseLagN2s[i],phaseLagN1s[i],phaseLag1s[i],phaseLag2s[i]]))
3265 3265 for j in range(numPairs):
3266 3266 fit = stats.linregress(time, angAllCCF[j,:])
3267 3267 slopes[j] = fit[0]
3268 3268
3269 3269 #Remove Outlier
3270 3270 # indOut = numpy.argmax(numpy.abs(slopes - numpy.mean(slopes)))
3271 3271 # slopes = numpy.delete(slopes,indOut)
3272 3272 # indOut = numpy.argmax(numpy.abs(slopes - numpy.mean(slopes)))
3273 3273 # slopes = numpy.delete(slopes,indOut)
3274 3274
3275 3275 radialVelocity = -numpy.mean(slopes)*(0.25/numpy.pi)*(c/freq)
3276 3276 radialError = numpy.std(slopes)*(0.25/numpy.pi)*(c/freq)
3277 3277 meteorAux[-2] = radialError
3278 3278 meteorAux[-3] = radialVelocity
3279 3279
3280 3280 #Setting Error
3281 3281 #Number 15: Radial Drift velocity or projected horizontal velocity exceeds 200 m/s
3282 3282 if numpy.abs(radialVelocity) > 200:
3283 3283 meteorAux[-1] = 15
3284 3284 #Number 12: Poor fit to CCF variation for estimation of radial drift velocity
3285 3285 elif radialError > radialStdThresh:
3286 3286 meteorAux[-1] = 12
3287 3287
3288 3288 listMeteors1.append(meteorAux)
3289 3289 return listMeteors1
3290 3290
3291 3291 def __setNewArrays(self, listMeteors, date, heiRang):
3292 3292
3293 3293 #New arrays
3294 3294 arrayMeteors = numpy.array(listMeteors)
3295 3295 arrayParameters = numpy.zeros((len(listMeteors), 13))
3296 3296
3297 3297 #Date inclusion
3298 3298 # date = re.findall(r'\((.*?)\)', date)
3299 3299 # date = date[0].split(',')
3300 3300 # date = map(int, date)
3301 3301 #
3302 3302 # if len(date)<6:
3303 3303 # date.append(0)
3304 3304 #
3305 3305 # date = [date[0]*10000 + date[1]*100 + date[2], date[3]*10000 + date[4]*100 + date[5]]
3306 3306 # arrayDate = numpy.tile(date, (len(listMeteors), 1))
3307 3307 arrayDate = numpy.tile(date, (len(listMeteors)))
3308 3308
3309 3309 #Meteor array
3310 3310 # arrayMeteors[:,0] = heiRang[arrayMeteors[:,0].astype(int)]
3311 3311 # arrayMeteors = numpy.hstack((arrayDate, arrayMeteors))
3312 3312
3313 3313 #Parameters Array
3314 3314 arrayParameters[:,0] = arrayDate #Date
3315 3315 arrayParameters[:,1] = heiRang[arrayMeteors[:,0].astype(int)] #Range
3316 3316 arrayParameters[:,6:8] = arrayMeteors[:,-3:-1] #Radial velocity and its error
3317 3317 arrayParameters[:,8:12] = arrayMeteors[:,7:11] #Phases
3318 3318 arrayParameters[:,-1] = arrayMeteors[:,-1] #Error
3319 3319
3320 3320
3321 3321 return arrayParameters
3322 3322
3323 3323 class CorrectSMPhases(Operation):
3324 3324
3325 3325 def run(self, dataOut, phaseOffsets, hmin = 50, hmax = 150, azimuth = 45, channelPositions = None):
3326 3326
3327 3327 arrayParameters = dataOut.data_param
3328 3328 pairsList = []
3329 3329 pairx = (0,1)
3330 3330 pairy = (2,3)
3331 3331 pairsList.append(pairx)
3332 3332 pairsList.append(pairy)
3333 3333 jph = numpy.zeros(4)
3334 3334
3335 3335 phaseOffsets = numpy.array(phaseOffsets)*numpy.pi/180
3336 3336 # arrayParameters[:,8:12] = numpy.unwrap(arrayParameters[:,8:12] + phaseOffsets)
3337 3337 arrayParameters[:,8:12] = numpy.angle(numpy.exp(1j*(arrayParameters[:,8:12] + phaseOffsets)))
3338 3338
3339 3339 meteorOps = SMOperations()
3340 3340 if channelPositions is None:
3341 3341 # channelPositions = [(2.5,0), (0,2.5), (0,0), (0,4.5), (-2,0)] #T
3342 3342 channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)] #Estrella
3343 3343
3344 3344 pairslist0, distances = meteorOps.getPhasePairs(channelPositions)
3345 3345 h = (hmin,hmax)
3346 3346
3347 3347 arrayParameters = meteorOps.getMeteorParams(arrayParameters, azimuth, h, pairsList, distances, jph)
3348 3348
3349 3349 dataOut.data_param = arrayParameters
3350 3350 return
3351 3351
3352 3352 class SMPhaseCalibration(Operation):
3353 3353
3354 3354 __buffer = None
3355 3355
3356 3356 __initime = None
3357 3357
3358 3358 __dataReady = False
3359 3359
3360 3360 __isConfig = False
3361 3361
3362 3362 def __checkTime(self, currentTime, initTime, paramInterval, outputInterval):
3363 3363
3364 3364 dataTime = currentTime + paramInterval
3365 3365 deltaTime = dataTime - initTime
3366 3366
3367 3367 if deltaTime >= outputInterval or deltaTime < 0:
3368 3368 return True
3369 3369
3370 3370 return False
3371 3371
3372 3372 def __getGammas(self, pairs, d, phases):
3373 3373 gammas = numpy.zeros(2)
3374 3374
3375 3375 for i in range(len(pairs)):
3376 3376
3377 3377 pairi = pairs[i]
3378 3378
3379 3379 phip3 = phases[:,pairi[0]]
3380 3380 d3 = d[pairi[0]]
3381 3381 phip2 = phases[:,pairi[1]]
3382 3382 d2 = d[pairi[1]]
3383 3383 #Calculating gamma
3384 3384 # jdcos = alp1/(k*d1)
3385 3385 # jgamma = numpy.angle(numpy.exp(1j*(d0*alp1/d1 - alp0)))
3386 3386 jgamma = -phip2*d3/d2 - phip3
3387 3387 jgamma = numpy.angle(numpy.exp(1j*jgamma))
3388 3388 # jgamma[jgamma>numpy.pi] -= 2*numpy.pi
3389 3389 # jgamma[jgamma<-numpy.pi] += 2*numpy.pi
3390 3390
3391 3391 #Revised distribution
3392 3392 jgammaArray = numpy.hstack((jgamma,jgamma+0.5*numpy.pi,jgamma-0.5*numpy.pi))
3393 3393
3394 3394 #Histogram
3395 3395 nBins = 64
3396 3396 rmin = -0.5*numpy.pi
3397 3397 rmax = 0.5*numpy.pi
3398 3398 phaseHisto = numpy.histogram(jgammaArray, bins=nBins, range=(rmin,rmax))
3399 3399
3400 3400 meteorsY = phaseHisto[0]
3401 3401 phasesX = phaseHisto[1][:-1]
3402 3402 width = phasesX[1] - phasesX[0]
3403 3403 phasesX += width/2
3404 3404
3405 3405 #Gaussian aproximation
3406 3406 bpeak = meteorsY.argmax()
3407 3407 peak = meteorsY.max()
3408 3408 jmin = bpeak - 5
3409 3409 jmax = bpeak + 5 + 1
3410 3410
3411 3411 if jmin<0:
3412 3412 jmin = 0
3413 3413 jmax = 6
3414 3414 elif jmax > meteorsY.size:
3415 3415 jmin = meteorsY.size - 6
3416 3416 jmax = meteorsY.size
3417 3417
3418 3418 x0 = numpy.array([peak,bpeak,50])
3419 3419 coeff = optimize.leastsq(self.__residualFunction, x0, args=(meteorsY[jmin:jmax], phasesX[jmin:jmax]))
3420 3420
3421 3421 #Gammas
3422 3422 gammas[i] = coeff[0][1]
3423 3423
3424 3424 return gammas
3425 3425
3426 3426 def __residualFunction(self, coeffs, y, t):
3427 3427
3428 3428 return y - self.__gauss_function(t, coeffs)
3429 3429
3430 3430 def __gauss_function(self, t, coeffs):
3431 3431
3432 3432 return coeffs[0]*numpy.exp(-0.5*((t - coeffs[1]) / coeffs[2])**2)
3433 3433
3434 3434 def __getPhases(self, azimuth, h, pairsList, d, gammas, meteorsArray):
3435 3435 meteorOps = SMOperations()
3436 3436 nchan = 4
3437 3437 pairx = pairsList[0] #x es 0
3438 3438 pairy = pairsList[1] #y es 1
3439 3439 center_xangle = 0
3440 3440 center_yangle = 0
3441 3441 range_angle = numpy.array([10*numpy.pi,numpy.pi,numpy.pi/2,numpy.pi/4])
3442 3442 ntimes = len(range_angle)
3443 3443
3444 3444 nstepsx = 20
3445 3445 nstepsy = 20
3446 3446
3447 3447 for iz in range(ntimes):
3448 3448 min_xangle = -range_angle[iz]/2 + center_xangle
3449 3449 max_xangle = range_angle[iz]/2 + center_xangle
3450 3450 min_yangle = -range_angle[iz]/2 + center_yangle
3451 3451 max_yangle = range_angle[iz]/2 + center_yangle
3452 3452
3453 3453 inc_x = (max_xangle-min_xangle)/nstepsx
3454 3454 inc_y = (max_yangle-min_yangle)/nstepsy
3455 3455
3456 3456 alpha_y = numpy.arange(nstepsy)*inc_y + min_yangle
3457 3457 alpha_x = numpy.arange(nstepsx)*inc_x + min_xangle
3458 3458 penalty = numpy.zeros((nstepsx,nstepsy))
3459 3459 jph_array = numpy.zeros((nchan,nstepsx,nstepsy))
3460 3460 jph = numpy.zeros(nchan)
3461 3461
3462 3462 # Iterations looking for the offset
3463 3463 for iy in range(int(nstepsy)):
3464 3464 for ix in range(int(nstepsx)):
3465 3465 d3 = d[pairsList[1][0]]
3466 3466 d2 = d[pairsList[1][1]]
3467 3467 d5 = d[pairsList[0][0]]
3468 3468 d4 = d[pairsList[0][1]]
3469 3469
3470 3470 alp2 = alpha_y[iy] #gamma 1
3471 3471 alp4 = alpha_x[ix] #gamma 0
3472 3472
3473 3473 alp3 = -alp2*d3/d2 - gammas[1]
3474 3474 alp5 = -alp4*d5/d4 - gammas[0]
3475 3475 # jph[pairy[1]] = alpha_y[iy]
3476 3476 # jph[pairy[0]] = -gammas[1] - alpha_y[iy]*d[pairy[1]]/d[pairy[0]]
3477 3477
3478 3478 # jph[pairx[1]] = alpha_x[ix]
3479 3479 # jph[pairx[0]] = -gammas[0] - alpha_x[ix]*d[pairx[1]]/d[pairx[0]]
3480 3480 jph[pairsList[0][1]] = alp4
3481 3481 jph[pairsList[0][0]] = alp5
3482 3482 jph[pairsList[1][0]] = alp3
3483 3483 jph[pairsList[1][1]] = alp2
3484 3484 jph_array[:,ix,iy] = jph
3485 3485 # d = [2.0,2.5,2.5,2.0]
3486 3486 #falta chequear si va a leer bien los meteoros
3487 3487 meteorsArray1 = meteorOps.getMeteorParams(meteorsArray, azimuth, h, pairsList, d, jph)
3488 3488 error = meteorsArray1[:,-1]
3489 3489 ind1 = numpy.where(error==0)[0]
3490 3490 penalty[ix,iy] = ind1.size
3491 3491
3492 3492 i,j = numpy.unravel_index(penalty.argmax(), penalty.shape)
3493 3493 phOffset = jph_array[:,i,j]
3494 3494
3495 3495 center_xangle = phOffset[pairx[1]]
3496 3496 center_yangle = phOffset[pairy[1]]
3497 3497
3498 3498 phOffset = numpy.angle(numpy.exp(1j*jph_array[:,i,j]))
3499 3499 phOffset = phOffset*180/numpy.pi
3500 3500 return phOffset
3501 3501
3502 3502
3503 3503 def run(self, dataOut, hmin, hmax, channelPositions=None, nHours = 1):
3504 3504
3505 3505 dataOut.flagNoData = True
3506 3506 self.__dataReady = False
3507 3507 dataOut.outputInterval = nHours*3600
3508 3508
3509 3509 if self.__isConfig == False:
3510 3510 # self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
3511 3511 #Get Initial LTC time
3512 3512 self.__initime = datetime.datetime.utcfromtimestamp(dataOut.utctime)
3513 3513 self.__initime = (self.__initime.replace(minute = 0, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
3514 3514
3515 3515 self.__isConfig = True
3516 3516
3517 3517 if self.__buffer is None:
3518 3518 self.__buffer = dataOut.data_param.copy()
3519 3519
3520 3520 else:
3521 3521 self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
3522 3522
3523 3523 self.__dataReady = self.__checkTime(dataOut.utctime, self.__initime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
3524 3524
3525 3525 if self.__dataReady:
3526 3526 dataOut.utctimeInit = self.__initime
3527 3527 self.__initime += dataOut.outputInterval #to erase time offset
3528 3528
3529 3529 freq = dataOut.frequency
3530 3530 c = dataOut.C #m/s
3531 3531 lamb = c/freq
3532 3532 k = 2*numpy.pi/lamb
3533 3533 azimuth = 0
3534 3534 h = (hmin, hmax)
3535 3535 # pairs = ((0,1),(2,3)) #Estrella
3536 3536 # pairs = ((1,0),(2,3)) #T
3537 3537
3538 3538 if channelPositions is None:
3539 3539 # channelPositions = [(2.5,0), (0,2.5), (0,0), (0,4.5), (-2,0)] #T
3540 3540 channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)] #Estrella
3541 3541 meteorOps = SMOperations()
3542 3542 pairslist0, distances = meteorOps.getPhasePairs(channelPositions)
3543 3543
3544 3544 #Checking correct order of pairs
3545 3545 pairs = []
3546 3546 if distances[1] > distances[0]:
3547 3547 pairs.append((1,0))
3548 3548 else:
3549 3549 pairs.append((0,1))
3550 3550
3551 3551 if distances[3] > distances[2]:
3552 3552 pairs.append((3,2))
3553 3553 else:
3554 3554 pairs.append((2,3))
3555 3555 # distances1 = [-distances[0]*lamb, distances[1]*lamb, -distances[2]*lamb, distances[3]*lamb]
3556 3556
3557 3557 meteorsArray = self.__buffer
3558 3558 error = meteorsArray[:,-1]
3559 3559 boolError = (error==0)|(error==3)|(error==4)|(error==13)|(error==14)
3560 3560 ind1 = numpy.where(boolError)[0]
3561 3561 meteorsArray = meteorsArray[ind1,:]
3562 3562 meteorsArray[:,-1] = 0
3563 3563 phases = meteorsArray[:,8:12]
3564 3564
3565 3565 #Calculate Gammas
3566 3566 gammas = self.__getGammas(pairs, distances, phases)
3567 3567 # gammas = numpy.array([-21.70409463,45.76935864])*numpy.pi/180
3568 3568 #Calculate Phases
3569 3569 phasesOff = self.__getPhases(azimuth, h, pairs, distances, gammas, meteorsArray)
3570 3570 phasesOff = phasesOff.reshape((1,phasesOff.size))
3571 3571 dataOut.data_output = -phasesOff
3572 3572 dataOut.flagNoData = False
3573 3573 self.__buffer = None
3574 3574
3575 3575
3576 3576 return
3577 3577
3578 3578 class SMOperations():
3579 3579
3580 3580 def __init__(self):
3581 3581
3582 3582 return
3583 3583
3584 3584 def getMeteorParams(self, arrayParameters0, azimuth, h, pairsList, distances, jph):
3585 3585
3586 3586 arrayParameters = arrayParameters0.copy()
3587 3587 hmin = h[0]
3588 3588 hmax = h[1]
3589 3589
3590 3590 #Calculate AOA (Error N 3, 4)
3591 3591 #JONES ET AL. 1998
3592 3592 AOAthresh = numpy.pi/8
3593 3593 error = arrayParameters[:,-1]
3594 3594 phases = -arrayParameters[:,8:12] + jph
3595 3595 # phases = numpy.unwrap(phases)
3596 3596 arrayParameters[:,3:6], arrayParameters[:,-1] = self.__getAOA(phases, pairsList, distances, error, AOAthresh, azimuth)
3597 3597
3598 3598 #Calculate Heights (Error N 13 and 14)
3599 3599 error = arrayParameters[:,-1]
3600 3600 Ranges = arrayParameters[:,1]
3601 3601 zenith = arrayParameters[:,4]
3602 3602 arrayParameters[:,2], arrayParameters[:,-1] = self.__getHeights(Ranges, zenith, error, hmin, hmax)
3603 3603
3604 3604 #----------------------- Get Final data ------------------------------------
3605 3605 # error = arrayParameters[:,-1]
3606 3606 # ind1 = numpy.where(error==0)[0]
3607 3607 # arrayParameters = arrayParameters[ind1,:]
3608 3608
3609 3609 return arrayParameters
3610 3610
3611 3611 def __getAOA(self, phases, pairsList, directions, error, AOAthresh, azimuth):
3612 3612
3613 3613 arrayAOA = numpy.zeros((phases.shape[0],3))
3614 3614 cosdir0, cosdir = self.__getDirectionCosines(phases, pairsList,directions)
3615 3615
3616 3616 arrayAOA[:,:2] = self.__calculateAOA(cosdir, azimuth)
3617 3617 cosDirError = numpy.sum(numpy.abs(cosdir0 - cosdir), axis = 1)
3618 3618 arrayAOA[:,2] = cosDirError
3619 3619
3620 3620 azimuthAngle = arrayAOA[:,0]
3621 3621 zenithAngle = arrayAOA[:,1]
3622 3622
3623 3623 #Setting Error
3624 3624 indError = numpy.where(numpy.logical_or(error == 3, error == 4))[0]
3625 3625 error[indError] = 0
3626 3626 #Number 3: AOA not fesible
3627 3627 indInvalid = numpy.where(numpy.logical_and((numpy.logical_or(numpy.isnan(zenithAngle), numpy.isnan(azimuthAngle))),error == 0))[0]
3628 3628 error[indInvalid] = 3
3629 3629 #Number 4: Large difference in AOAs obtained from different antenna baselines
3630 3630 indInvalid = numpy.where(numpy.logical_and(cosDirError > AOAthresh,error == 0))[0]
3631 3631 error[indInvalid] = 4
3632 3632 return arrayAOA, error
3633 3633
3634 3634 def __getDirectionCosines(self, arrayPhase, pairsList, distances):
3635 3635
3636 3636 #Initializing some variables
3637 3637 ang_aux = numpy.array([-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8])*2*numpy.pi
3638 3638 ang_aux = ang_aux.reshape(1,ang_aux.size)
3639 3639
3640 3640 cosdir = numpy.zeros((arrayPhase.shape[0],2))
3641 3641 cosdir0 = numpy.zeros((arrayPhase.shape[0],2))
3642 3642
3643 3643
3644 3644 for i in range(2):
3645 3645 ph0 = arrayPhase[:,pairsList[i][0]]
3646 3646 ph1 = arrayPhase[:,pairsList[i][1]]
3647 3647 d0 = distances[pairsList[i][0]]
3648 3648 d1 = distances[pairsList[i][1]]
3649 3649
3650 3650 ph0_aux = ph0 + ph1
3651 3651 ph0_aux = numpy.angle(numpy.exp(1j*ph0_aux))
3652 3652 # ph0_aux[ph0_aux > numpy.pi] -= 2*numpy.pi
3653 3653 # ph0_aux[ph0_aux < -numpy.pi] += 2*numpy.pi
3654 3654 #First Estimation
3655 3655 cosdir0[:,i] = (ph0_aux)/(2*numpy.pi*(d0 - d1))
3656 3656
3657 3657 #Most-Accurate Second Estimation
3658 3658 phi1_aux = ph0 - ph1
3659 3659 phi1_aux = phi1_aux.reshape(phi1_aux.size,1)
3660 3660 #Direction Cosine 1
3661 3661 cosdir1 = (phi1_aux + ang_aux)/(2*numpy.pi*(d0 + d1))
3662 3662
3663 3663 #Searching the correct Direction Cosine
3664 3664 cosdir0_aux = cosdir0[:,i]
3665 3665 cosdir0_aux = cosdir0_aux.reshape(cosdir0_aux.size,1)
3666 3666 #Minimum Distance
3667 3667 cosDiff = (cosdir1 - cosdir0_aux)**2
3668 3668 indcos = cosDiff.argmin(axis = 1)
3669 3669 #Saving Value obtained
3670 3670 cosdir[:,i] = cosdir1[numpy.arange(len(indcos)),indcos]
3671 3671
3672 3672 return cosdir0, cosdir
3673 3673
3674 3674 def __calculateAOA(self, cosdir, azimuth):
3675 3675 cosdirX = cosdir[:,0]
3676 3676 cosdirY = cosdir[:,1]
3677 3677
3678 3678 zenithAngle = numpy.arccos(numpy.sqrt(1 - cosdirX**2 - cosdirY**2))*180/numpy.pi
3679 3679 azimuthAngle = numpy.arctan2(cosdirX,cosdirY)*180/numpy.pi + azimuth#0 deg north, 90 deg east
3680 3680 angles = numpy.vstack((azimuthAngle, zenithAngle)).transpose()
3681 3681
3682 3682 return angles
3683 3683
3684 3684 def __getHeights(self, Ranges, zenith, error, minHeight, maxHeight):
3685 3685
3686 3686 Ramb = 375 #Ramb = c/(2*PRF)
3687 3687 Re = 6371 #Earth Radius
3688 3688 heights = numpy.zeros(Ranges.shape)
3689 3689
3690 3690 R_aux = numpy.array([0,1,2])*Ramb
3691 3691 R_aux = R_aux.reshape(1,R_aux.size)
3692 3692
3693 3693 Ranges = Ranges.reshape(Ranges.size,1)
3694 3694
3695 3695 Ri = Ranges + R_aux
3696 3696 hi = numpy.sqrt(Re**2 + Ri**2 + (2*Re*numpy.cos(zenith*numpy.pi/180)*Ri.transpose()).transpose()) - Re
3697 3697
3698 3698 #Check if there is a height between 70 and 110 km
3699 3699 h_bool = numpy.sum(numpy.logical_and(hi > minHeight, hi < maxHeight), axis = 1)
3700 3700 ind_h = numpy.where(h_bool == 1)[0]
3701 3701
3702 3702 hCorr = hi[ind_h, :]
3703 3703 ind_hCorr = numpy.where(numpy.logical_and(hi > minHeight, hi < maxHeight))
3704 3704
3705 3705 hCorr = hi[ind_hCorr][:len(ind_h)]
3706 3706 heights[ind_h] = hCorr
3707 3707
3708 3708 #Setting Error
3709 3709 #Number 13: Height unresolvable echo: not valid height within 70 to 110 km
3710 3710 #Number 14: Height ambiguous echo: more than one possible height within 70 to 110 km
3711 3711 indError = numpy.where(numpy.logical_or(error == 13, error == 14))[0]
3712 3712 error[indError] = 0
3713 3713 indInvalid2 = numpy.where(numpy.logical_and(h_bool > 1, error == 0))[0]
3714 3714 error[indInvalid2] = 14
3715 3715 indInvalid1 = numpy.where(numpy.logical_and(h_bool == 0, error == 0))[0]
3716 3716 error[indInvalid1] = 13
3717 3717
3718 3718 return heights, error
3719 3719
3720 3720 def getPhasePairs(self, channelPositions):
3721 3721 chanPos = numpy.array(channelPositions)
3722 3722 listOper = list(itertools.combinations(list(range(5)),2))
3723 3723
3724 3724 distances = numpy.zeros(4)
3725 3725 axisX = []
3726 3726 axisY = []
3727 3727 distX = numpy.zeros(3)
3728 3728 distY = numpy.zeros(3)
3729 3729 ix = 0
3730 3730 iy = 0
3731 3731
3732 3732 pairX = numpy.zeros((2,2))
3733 3733 pairY = numpy.zeros((2,2))
3734 3734
3735 3735 for i in range(len(listOper)):
3736 3736 pairi = listOper[i]
3737 3737
3738 3738 posDif = numpy.abs(chanPos[pairi[0],:] - chanPos[pairi[1],:])
3739 3739
3740 3740 if posDif[0] == 0:
3741 3741 axisY.append(pairi)
3742 3742 distY[iy] = posDif[1]
3743 3743 iy += 1
3744 3744 elif posDif[1] == 0:
3745 3745 axisX.append(pairi)
3746 3746 distX[ix] = posDif[0]
3747 3747 ix += 1
3748 3748
3749 3749 for i in range(2):
3750 3750 if i==0:
3751 3751 dist0 = distX
3752 3752 axis0 = axisX
3753 3753 else:
3754 3754 dist0 = distY
3755 3755 axis0 = axisY
3756 3756
3757 3757 side = numpy.argsort(dist0)[:-1]
3758 3758 axis0 = numpy.array(axis0)[side,:]
3759 3759 chanC = int(numpy.intersect1d(axis0[0,:], axis0[1,:])[0])
3760 3760 axis1 = numpy.unique(numpy.reshape(axis0,4))
3761 3761 side = axis1[axis1 != chanC]
3762 3762 diff1 = chanPos[chanC,i] - chanPos[side[0],i]
3763 3763 diff2 = chanPos[chanC,i] - chanPos[side[1],i]
3764 3764 if diff1<0:
3765 3765 chan2 = side[0]
3766 3766 d2 = numpy.abs(diff1)
3767 3767 chan1 = side[1]
3768 3768 d1 = numpy.abs(diff2)
3769 3769 else:
3770 3770 chan2 = side[1]
3771 3771 d2 = numpy.abs(diff2)
3772 3772 chan1 = side[0]
3773 3773 d1 = numpy.abs(diff1)
3774 3774
3775 3775 if i==0:
3776 3776 chanCX = chanC
3777 3777 chan1X = chan1
3778 3778 chan2X = chan2
3779 3779 distances[0:2] = numpy.array([d1,d2])
3780 3780 else:
3781 3781 chanCY = chanC
3782 3782 chan1Y = chan1
3783 3783 chan2Y = chan2
3784 3784 distances[2:4] = numpy.array([d1,d2])
3785 3785 # axisXsides = numpy.reshape(axisX[ix,:],4)
3786 3786 #
3787 3787 # channelCentX = int(numpy.intersect1d(pairX[0,:], pairX[1,:])[0])
3788 3788 # channelCentY = int(numpy.intersect1d(pairY[0,:], pairY[1,:])[0])
3789 3789 #
3790 3790 # ind25X = numpy.where(pairX[0,:] != channelCentX)[0][0]
3791 3791 # ind20X = numpy.where(pairX[1,:] != channelCentX)[0][0]
3792 3792 # channel25X = int(pairX[0,ind25X])
3793 3793 # channel20X = int(pairX[1,ind20X])
3794 3794 # ind25Y = numpy.where(pairY[0,:] != channelCentY)[0][0]
3795 3795 # ind20Y = numpy.where(pairY[1,:] != channelCentY)[0][0]
3796 3796 # channel25Y = int(pairY[0,ind25Y])
3797 3797 # channel20Y = int(pairY[1,ind20Y])
3798 3798
3799 3799 # pairslist = [(channelCentX, channel25X),(channelCentX, channel20X),(channelCentY,channel25Y),(channelCentY, channel20Y)]
3800 3800 pairslist = [(chanCX, chan1X),(chanCX, chan2X),(chanCY,chan1Y),(chanCY, chan2Y)]
3801 3801
3802 3802 return pairslist, distances
3803 3803 # def __getAOA(self, phases, pairsList, error, AOAthresh, azimuth):
3804 3804 #
3805 3805 # arrayAOA = numpy.zeros((phases.shape[0],3))
3806 3806 # cosdir0, cosdir = self.__getDirectionCosines(phases, pairsList)
3807 3807 #
3808 3808 # arrayAOA[:,:2] = self.__calculateAOA(cosdir, azimuth)
3809 3809 # cosDirError = numpy.sum(numpy.abs(cosdir0 - cosdir), axis = 1)
3810 3810 # arrayAOA[:,2] = cosDirError
3811 3811 #
3812 3812 # azimuthAngle = arrayAOA[:,0]
3813 3813 # zenithAngle = arrayAOA[:,1]
3814 3814 #
3815 3815 # #Setting Error
3816 3816 # #Number 3: AOA not fesible
3817 3817 # indInvalid = numpy.where(numpy.logical_and((numpy.logical_or(numpy.isnan(zenithAngle), numpy.isnan(azimuthAngle))),error == 0))[0]
3818 3818 # error[indInvalid] = 3
3819 3819 # #Number 4: Large difference in AOAs obtained from different antenna baselines
3820 3820 # indInvalid = numpy.where(numpy.logical_and(cosDirError > AOAthresh,error == 0))[0]
3821 3821 # error[indInvalid] = 4
3822 3822 # return arrayAOA, error
3823 3823 #
3824 3824 # def __getDirectionCosines(self, arrayPhase, pairsList):
3825 3825 #
3826 3826 # #Initializing some variables
3827 3827 # ang_aux = numpy.array([-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8])*2*numpy.pi
3828 3828 # ang_aux = ang_aux.reshape(1,ang_aux.size)
3829 3829 #
3830 3830 # cosdir = numpy.zeros((arrayPhase.shape[0],2))
3831 3831 # cosdir0 = numpy.zeros((arrayPhase.shape[0],2))
3832 3832 #
3833 3833 #
3834 3834 # for i in range(2):
3835 3835 # #First Estimation
3836 3836 # phi0_aux = arrayPhase[:,pairsList[i][0]] + arrayPhase[:,pairsList[i][1]]
3837 3837 # #Dealias
3838 3838 # indcsi = numpy.where(phi0_aux > numpy.pi)
3839 3839 # phi0_aux[indcsi] -= 2*numpy.pi
3840 3840 # indcsi = numpy.where(phi0_aux < -numpy.pi)
3841 3841 # phi0_aux[indcsi] += 2*numpy.pi
3842 3842 # #Direction Cosine 0
3843 3843 # cosdir0[:,i] = -(phi0_aux)/(2*numpy.pi*0.5)
3844 3844 #
3845 3845 # #Most-Accurate Second Estimation
3846 3846 # phi1_aux = arrayPhase[:,pairsList[i][0]] - arrayPhase[:,pairsList[i][1]]
3847 3847 # phi1_aux = phi1_aux.reshape(phi1_aux.size,1)
3848 3848 # #Direction Cosine 1
3849 3849 # cosdir1 = -(phi1_aux + ang_aux)/(2*numpy.pi*4.5)
3850 3850 #
3851 3851 # #Searching the correct Direction Cosine
3852 3852 # cosdir0_aux = cosdir0[:,i]
3853 3853 # cosdir0_aux = cosdir0_aux.reshape(cosdir0_aux.size,1)
3854 3854 # #Minimum Distance
3855 3855 # cosDiff = (cosdir1 - cosdir0_aux)**2
3856 3856 # indcos = cosDiff.argmin(axis = 1)
3857 3857 # #Saving Value obtained
3858 3858 # cosdir[:,i] = cosdir1[numpy.arange(len(indcos)),indcos]
3859 3859 #
3860 3860 # return cosdir0, cosdir
3861 3861 #
3862 3862 # def __calculateAOA(self, cosdir, azimuth):
3863 3863 # cosdirX = cosdir[:,0]
3864 3864 # cosdirY = cosdir[:,1]
3865 3865 #
3866 3866 # zenithAngle = numpy.arccos(numpy.sqrt(1 - cosdirX**2 - cosdirY**2))*180/numpy.pi
3867 3867 # azimuthAngle = numpy.arctan2(cosdirX,cosdirY)*180/numpy.pi + azimuth #0 deg north, 90 deg east
3868 3868 # angles = numpy.vstack((azimuthAngle, zenithAngle)).transpose()
3869 3869 #
3870 3870 # return angles
3871 3871 #
3872 3872 # def __getHeights(self, Ranges, zenith, error, minHeight, maxHeight):
3873 3873 #
3874 3874 # Ramb = 375 #Ramb = c/(2*PRF)
3875 3875 # Re = 6371 #Earth Radius
3876 3876 # heights = numpy.zeros(Ranges.shape)
3877 3877 #
3878 3878 # R_aux = numpy.array([0,1,2])*Ramb
3879 3879 # R_aux = R_aux.reshape(1,R_aux.size)
3880 3880 #
3881 3881 # Ranges = Ranges.reshape(Ranges.size,1)
3882 3882 #
3883 3883 # Ri = Ranges + R_aux
3884 3884 # hi = numpy.sqrt(Re**2 + Ri**2 + (2*Re*numpy.cos(zenith*numpy.pi/180)*Ri.transpose()).transpose()) - Re
3885 3885 #
3886 3886 # #Check if there is a height between 70 and 110 km
3887 3887 # h_bool = numpy.sum(numpy.logical_and(hi > minHeight, hi < maxHeight), axis = 1)
3888 3888 # ind_h = numpy.where(h_bool == 1)[0]
3889 3889 #
3890 3890 # hCorr = hi[ind_h, :]
3891 3891 # ind_hCorr = numpy.where(numpy.logical_and(hi > minHeight, hi < maxHeight))
3892 3892 #
3893 3893 # hCorr = hi[ind_hCorr]
3894 3894 # heights[ind_h] = hCorr
3895 3895 #
3896 3896 # #Setting Error
3897 3897 # #Number 13: Height unresolvable echo: not valid height within 70 to 110 km
3898 3898 # #Number 14: Height ambiguous echo: more than one possible height within 70 to 110 km
3899 3899 #
3900 3900 # indInvalid2 = numpy.where(numpy.logical_and(h_bool > 1, error == 0))[0]
3901 3901 # error[indInvalid2] = 14
3902 3902 # indInvalid1 = numpy.where(numpy.logical_and(h_bool == 0, error == 0))[0]
3903 3903 # error[indInvalid1] = 13
3904 3904 #
3905 3905 # return heights, error
3906 3906
3907 3907
3908 3908 class WeatherRadar(Operation):
3909 3909 '''
3910 3910 Function tat implements Weather Radar operations-
3911 3911 Input:
3912 3912 Output:
3913 3913 Parameters affected:
3914 3914 '''
3915 3915 isConfig = False
3916 3916
3917 3917 def __init__(self):
3918 3918 Operation.__init__(self)
3919 3919
3920 3920 def setup(self,dataOut,Pt=0,Gt=0,Gr=0,lambda_=0, aL=0,
3921 3921 tauW= 0,thetaT=0,thetaR=0,Km =0):
3922 3922 self.nCh = dataOut.nChannels
3923 3923 self.nHeis = dataOut.nHeights
3924 3924 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
3925 3925 self.Range = numpy.arange(dataOut.nHeights)*deltaHeight + dataOut.heightList[0]
3926 3926 self.Range = self.Range.reshape(1,self.nHeis)
3927 3927 self.Range = numpy.tile(self.Range,[self.nCh,1])
3928 3928 '''-----------1 Constante del Radar----------'''
3929 3929 self.Pt = Pt
3930 3930 self.Gt = Gt
3931 3931 self.Gr = Gr
3932 3932 self.lambda_ = lambda_
3933 3933 self.aL = aL
3934 3934 self.tauW = tauW
3935 3935 self.thetaT = thetaT
3936 3936 self.thetaR = thetaR
3937 3937 self.Km = Km
3938 3938 Numerator = ((4*numpy.pi)**3 * aL**2 * 16 *numpy.log(2))
3939 3939 Denominator = (Pt * Gt * Gr * lambda_**2 * SPEED_OF_LIGHT * tauW * numpy.pi*thetaT*thetaR)
3940 3940 self.RadarConstant = Numerator/Denominator
3941 3941 '''-----------2 Reflectividad del Radar y Factor de Reflectividad------'''
3942 3942 self.n_radar = numpy.zeros((self.nCh,self.nHeis))
3943 3943 self.Z_radar = numpy.zeros((self.nCh,self.nHeis))
3944 3944
3945 3945 def setMoments(self,dataOut,i):
3946 3946
3947 3947 type = dataOut.inputUnit
3948 3948 nCh = dataOut.nChannels
3949 3949 nHeis= dataOut.nHeights
3950 3950 data_param = numpy.zeros((nCh,4,nHeis))
3951 3951 if type == "Voltage":
3952 3952 data_param[:,0,:] = dataOut.dataPP_POW/(dataOut.nCohInt**2)
3953 3953 data_param[:,1,:] = dataOut.dataPP_DOP
3954 3954 data_param[:,2,:] = dataOut.dataPP_WIDTH
3955 3955 data_param[:,3,:] = dataOut.dataPP_SNR
3956 3956 if type == "Spectra":
3957 3957 data_param[:,0,:] = dataOut.data_POW
3958 3958 data_param[:,1,:] = dataOut.data_DOP
3959 3959 data_param[:,2,:] = dataOut.data_WIDTH
3960 3960 def setMoments(self,dataOut,i):
3961 3961 data_param[:,3,:] = dataOut.data_SNR
3962 3962
3963 3963 return data_param[:,i,:]
3964 3964
3965 3965
3966 3966 def run(self,dataOut,Pt=25,Gt=200.0,Gr=50.0,lambda_=0.32, aL=2.5118,
3967 3967 tauW= 4.0e-6,thetaT=0.165,thetaR=0.367,Km =0.93):
3968 3968
3969 3969 if not self.isConfig:
3970 3970 self.setup(dataOut= dataOut,Pt=25,Gt=200.0,Gr=50.0,lambda_=0.32, aL=2.5118,
3971 3971 tauW= 4.0e-6,thetaT=0.165,thetaR=0.367,Km =0.93)
3972 3972 self.isConfig = True
3973 3973 '''-----------------------------Potencia de Radar -Signal S-----------------------------'''
3974 3974 Pr = self.setMoments(dataOut,0)
3975 3975
3976 3976 for R in range(self.nHeis):
3977 3977 self.n_radar[:,R] = self.RadarConstant*Pr[:,R]* (self.Range[:,R])**2
3978 3978
3979 3979 self.Z_radar[:,R] = self.n_radar[:,R]* self.lambda_**4/( numpy.pi**5 * self.Km**2)
3980 3980
3981 3981 '''----------- Factor de Reflectividad Equivalente lamda_ < 10 cm , lamda_= 3.2cm-------'''
3982 3982 Zeh = self.Z_radar
3983 3983 dBZeh = 10*numpy.log10(Zeh)
3984 3984 dataOut.factor_Zeh= dBZeh
3985 3985 self.n_radar = numpy.zeros((self.nCh,self.nHeis))
3986 3986 self.Z_radar = numpy.zeros((self.nCh,self.nHeis))
3987 3987
3988 3988 return dataOut
3989 3989
3990 3990 class PedestalInformation(Operation):
3991 3991 path_ped = None
3992 3992 path_adq = None
3993 3993 t_Interval_p = None
3994 3994 n_Muestras_p = None
3995 3995 isConfig = False
3996 3996 blocksPerfile= None
3997 3997 f_a_p = None
3998 3998 online = None
3999 3999 angulo_adq = None
4000 4000 nro_file = None
4001 4001 nro_key_p = None
4002 4002 tmp = None
4003 4003
4004 4004
4005 4005 def __init__(self):
4006 4006 Operation.__init__(self)
4007 4007
4008 4008
4009 4009 def getAnguloProfile(self,utc_adq,list_pedestal):
4010 4010 ##print("NEW-METHOD")
4011 4011 utc_adq = utc_adq
4012 4012 list_pedestal = list_pedestal
4013 4013 utc_ped_list = []
4014 4014
4015 4015 for i in range(len(list_pedestal)):
4016 4016 #print(i)# OJO IDENTIFICADOR DE SINCRONISMO
4017 4017 utc_ped_list.append(self.gettimeutcfromDirFilename(path=self.path_ped,file=list_pedestal[i]))
4018 4018
4019 4019 nro_file,utc_ped,utc_ped_1 =self.getNROFile(utc_adq,utc_ped_list)
4020 4020 #print("utc_adq",utc_adq)
4021 4021 ####print("utc_ped",utc_ped)
4022 4022 ####print("DIFF",utc_adq-utc_ped)
4023 4023 ####print("nro_file",nro_file)
4024 4024 if nro_file < 0:
4025 4025 #print("-----------------------------------------------------------------")
4026 4026 #print("INSERTANDO ANGULO NAN")
4027 4027 return numpy.NaN
4028 4028 else:
4029 4029 nro_key_p = int((utc_adq-utc_ped)/self.t_Interval_p)-1 # ojito al -1 estimado alex
4030 4030 ff_pedestal = list_pedestal[nro_file]
4031 4031 #angulo = self.getDatavaluefromDirFilename(path=self.path_ped,file=ff_pedestal,value="azimuth")
4032 4032 angulo = self.getDatavaluefromDirFilename(path=self.path_ped,file=ff_pedestal,value="azi_pos")
4033 4033 if 99>=nro_key_p>0:
4034 4034 ##print("angulo_array :",angulo[nro_key_p])
4035 4035 return angulo[nro_key_p]
4036 4036 else:
4037 4037 #print("-----------------------------------------------------------------")
4038 4038 return numpy.NaN
4039 4039
4040 4040
4041 4041 def getfirstFilefromPath(self,path,meta,ext):
4042 4042 validFilelist = []
4043 4043 #print("SEARH",path)
4044 4044 try:
4045 4045 fileList = os.listdir(path)
4046 4046 except:
4047 4047 print("check path - fileList")
4048 4048 if len(fileList)<1:
4049 4049 return None
4050 4050 # meta 1234 567 8-18 BCDE
4051 4051 # H,D,PE YYYY DDD EPOC .ext
4052 4052
4053 4053 for thisFile in fileList:
4054 4054 #print("HI",thisFile)
4055 4055 if meta =="PE":
4056 4056 try:
4057 4057 number= int(thisFile[len(meta)+7:len(meta)+17])
4058 4058 except:
4059 4059 print("There is a file or folder with different format")
4060 4060 if meta == "D":
4061 4061 try:
4062 4062 number= int(thisFile[8:11])
4063 4063 except:
4064 4064 print("There is a file or folder with different format")
4065 4065
4066 4066 if not isNumber(str=number):
4067 4067 continue
4068 4068 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
4069 4069 continue
4070 4070 validFilelist.sort()
4071 4071 validFilelist.append(thisFile)
4072 4072 if len(validFilelist)>0:
4073 4073 validFilelist = sorted(validFilelist,key=str.lower)
4074 4074 return validFilelist
4075 4075 return None
4076 4076
4077 4077 def gettimeutcfromDirFilename(self,path,file):
4078 4078 dir_file= path+"/"+file
4079 4079 fp = h5py.File(dir_file,'r')
4080 4080 #epoc = fp['Metadata'].get('utctimeInit')[()]
4081 4081 epoc = fp['Data'].get('utc')[()]
4082 4082 fp.close()
4083 4083 return epoc
4084 4084
4085 4085 def gettimeutcadqfromDirFilename(self,path,file):
4086 dir_file= path+"/"+file
4087 fp = h5py.File(dir_file,'r')
4088 epoc = fp['Metadata'].get('utctimeInit')[()]
4089 #epoc = fp['Data'].get('utc')[()]
4090 fp.close()
4091 return epoc
4086 pass
4092 4087
4093 4088 def getDatavaluefromDirFilename(self,path,file,value):
4094 4089 dir_file= path+"/"+file
4095 4090 fp = h5py.File(dir_file,'r')
4096 4091 array = fp['Data'].get(value)[()]
4097 4092 fp.close()
4098 4093 return array
4099 4094
4100 def getFile_KeyP(self,list_pedestal,list_adq):
4101 print(list_pedestal)
4102 print(list_adq)
4103 4095
4104 4096 def getNROFile(self,utc_adq,utc_ped_list):
4105 4097 c=0
4106 #print("insidegetNROFile")
4107 4098 #print(utc_adq)
4108 4099 #print(len(utc_ped_list))
4109 4100 for i in range(len(utc_ped_list)):
4110 4101 if utc_adq>utc_ped_list[i]:
4111 4102 #print("mayor")
4112 4103 #print("utc_ped_list",utc_ped_list[i])
4113 4104 c +=1
4114 4105
4115 4106 return c-1,utc_ped_list[c-1],utc_ped_list[c]
4116 4107
4117 4108 def verificarNROFILE(self,dataOut,utc_ped,f_a_p,n_Muestras_p):
4118 var =int(f_a_p/n_Muestras_p)
4119 flag=0
4120 for i in range(var):
4121 if dataOut.utctime+i==utc_ped:
4122 flag==1
4123 break
4124 return flag
4125
4126 #def setup_offline(self,dataOut,list_pedestal,list_adq):
4127 def setup_offline(self,dataOut,list_pedestal):
4128
4129 print("SETUP OFFLINE")
4130 ####print(self.path_ped)
4131 #print(self.path_adq)
4132 ####print(len(self.list_pedestal))
4133 #print(len(self.list_adq))
4134 utc_ped_list=[]
4135 for i in range(len(self.list_pedestal)):
4136 #print(i)# OJO IDENTIFICADOR DE SINCRONISMO
4137 utc_ped_list.append(self.gettimeutcfromDirFilename(path=self.path_ped,file=self.list_pedestal[i]))
4138
4139 #utc_ped_list= utc_ped_list
4140 ###utc_adq = self.gettimeutcadqfromDirFilename(path=self.path_adq,file=self.list_adq[0])
4141 ####print("dios existe donde esta")
4109 pass
4142 4110
4143 #####print("utc_ped_list",utc_ped_list)
4144 #print("utc_adq",utc_adq)
4145 # utc_adq_dataOut
4146 utc_adq_dataOut =dataOut.utctime
4147 ####print("OFFLINE-UTC_ADQ_dataout",utc_adq_dataOut)
4148
4149 nro_file,utc_ped,utc_ped_1 = self.getNROFile(utc_adq=utc_adq_dataOut, utc_ped_list= utc_ped_list)
4150
4151 ####print("nro_file",nro_file,"utc_ped",utc_ped)
4152 ####print("nro_file",i)
4153 nro_key_p = int((utc_adq_dataOut-utc_ped)/self.t_Interval_p)-1 # ojito al -1 estimado alex
4154 ####print("nro_key_p",nro_key_p)
4155
4156 ff_pedestal = self.list_
4157 pedestal[nro_file]
4158 #angulo = self.getDatavaluefromDirFilename(path=self.path_ped,file=ff_pedestal,value="azimuth")
4159 angulo = self.getDatavaluefromDirFilename(path=self.path_ped,file=ff_pedestal,value="azi_pos")
4160
4161 ####print("utc_pedestal_init :",utc_ped+nro_key_p*self.t_Interval_p)
4162 if nro_key_p>0:
4163 print("angulo_array :",angulo[nro_key_p])
4164 self.nro_file = nro_file
4165 self.nro_key_p = nro_key_p
4111 def setup_offline(self,dataOut,list_pedestal):
4112 pass
4166 4113
4167 4114 def setup_online(self,dataOut):
4168 utc_adq =dataOut.utctime
4169 ####print("Online-utc_adq",utc_adq)
4170 ####print(len(self.list_pedestal))
4171 utc_ped_list=[]
4172 for i in range(len(self.list_pedestal)):
4173 utc_ped_list.append(self.gettimeutcfromDirFilename(path=self.path_ped,file=self.list_pedestal[i]))
4174 ####print(utc_ped_list[:20])
4175 ####print(utc_ped_list[488:498])
4176 ####print("ultimo UTC-PEDESTAL",utc_ped_list[-1])
4177 nro_file,utc_ped,utc_ped_1 = self.getNROFile(utc_adq=utc_adq, utc_ped_list= utc_ped_list)
4178 ####print("nro_file",nro_file,"utc_ped",utc_ped,"utc_ped_1",utc_ped_1)
4179 ####print("name_PEDESTAL",self.list_pedestal[nro_file])
4180 nro_key_p = int((utc_adq-utc_ped)/self.t_Interval_p)-1
4181 ####print("nro_key_p",nro_key_p)
4182 ff_pedestal = self.list_pedestal[nro_file]
4183 #angulo = self.getDatavaluefromDirFilename(path=self.path_ped,file=ff_pedestal,value="azimuth")
4184 angulo = self.getDatavaluefromDirFilename(path=self.path_ped,file=ff_pedestal,value="azi_pos")
4185
4186 ####print("utc_pedestal_init :",utc_ped+nro_key_p*self.t_Interval_p)
4187 ####print("angulo_array :",angulo[nro_key_p])
4188 self.nro_file = nro_file
4189 self.nro_key_p = nro_key_p
4115 pass
4190 4116
4191 4117 #def setup(self,dataOut,path_ped,path_adq,t_Interval_p,n_Muestras_p,blocksPerfile,f_a_p,online):
4192 4118 def setup(self,dataOut,path_ped,t_Interval_p,n_Muestras_p,blocksPerfile,f_a_p,online):
4193 print("SETUP PEDESTAL")
4119 #print("SETUP PEDESTAL")
4194 4120 self.__dataReady = False
4195 4121 self.path_ped = path_ped
4196 4122 #self.path_adq = path_adq
4197 4123 self.t_Interval_p = t_Interval_p
4198 4124 self.n_Muestras_p = n_Muestras_p
4199 4125 self.blocksPerfile= blocksPerfile
4200 #print("dasdadasdasda",self.blocksPerfile)
4126 #print("self.blocksPerfile",self.blocksPerfile)
4201 4127 self.f_a_p = f_a_p
4202 4128 self.online = online
4203 4129 self.angulo_adq = numpy.zeros(self.blocksPerfile)
4204 4130 self.__profIndex = 0
4205 4131 self.tmp = 0
4206 4132 self.c_ped = 0
4207 print(self.path_ped)
4208 #print(self.path_adq)
4133 #print(self.path_ped)
4134 #### print("self.path_adq",self.path_adq)
4209 4135 self.list_pedestal = self.getfirstFilefromPath(path=self.path_ped,meta="PE",ext=".hdf5")
4210 ####print("LIST NEW", self.list_pedestal[:20])
4211 #self.list_adq = self.getfirstFilefromPath(path=self.path_adq,meta="D",ext=".hdf5")
4212 print("*************Longitud list pedestal****************",len(self.list_pedestal))
4213 '''
4214 if self.online:
4215 print("Enable Online")
4216 self.setup_online(dataOut)
4217 else:
4218 #self.setup_offline(dataOut,list_pedestal=self.list_pedestal,list_adq=self.list_adq)
4219 self.setup_offline(dataOut,list_pedestal=self.list_pedestal)
4220 '''
4136 #### print("self.list_pedestal", self.list_pedestal[:20])
4137 #### self.list_adq = self.getfirstFilefromPath(path=self.path_adq,meta="D",ext=".hdf5")
4138 #print("*************Longitud list pedestal****************",len(self.list_pedestal))
4221 4139
4222 4140 def setNextFileP(self,dataOut):
4223 if self.online:
4224 data_pedestal = self.setNextFileonline()
4225 else:
4226 data_pedestal = self.setNextFileoffline(dataOut)
4227
4228 return data_pedestal
4229
4230
4141 pass
4231 4142
4232 4143 def checkPedFile(self,path,nro_file):
4233 try:
4234 utc_pedestal_now = self.gettimeutcfromDirFilename(path=path,file=self.list_pedestal[nro_file])
4235 utc_pedestal_past = self.gettimeutcfromDirFilename(path=path,file=self.list_pedestal[nro_file-1])
4236 diff_utc = utc_pedestal_now - utc_pedestal_past
4237 except:
4238 diff_utc = -1
4239 return diff_utc
4144 pass
4240 4145
4241 4146 def setNextFileoffline(self,dataOut):
4242 ####print("error")
4243 ####print("no entiendo")
4244 flag_NOPedfile = False
4245 cont_NOPedFile = 0
4246 if self.nro_file<0:
4247 ####print("adq empieza antes")
4248 return numpy.ones(self.blocksPerfile)*numpy.nan
4249 ####print("INICIO-----------------------------------------")
4250 sleep(3)
4251 for j in range(self.blocksPerfile):
4252 ####print(j)
4253 iterador = self.nro_key_p + self.f_a_p*self.c_ped
4254 self.c_ped = self.c_ped + 1
4255 ####print("Iterador-->", iterador)
4256 if iterador < self.n_Muestras_p:
4257 self.nro_file = self.nro_file
4258 else:
4259 if flag_NOPedfile==False:
4260 ###########################
4261 self.nro_file = self.nro_file +1
4262 ###########################
4263 ####print("nro_file",self.nro_file)
4264 diff_utc = self.checkPedFile(path=self.path_ped,nro_file=self.nro_file)
4265 ####print("diff_utc",diff_utc)
4266 if diff_utc==1:
4267 utc_ped_setnext=self.gettimeutcfromDirFilename(path=self.path_ped,file=self.list_pedestal[self.nro_file])
4268 utc_adq_setnext=dataOut.utctime
4269 ####print("utc_pedestal",utc_ped_setnext)
4270 ####print("utc_adq",utc_adq_setnext)
4271 ####print("self.c_ped",self.c_ped)
4272 #dif = self.blocksPerfile-(self.nro_key_p+self.f_a_p*(self.c_ped-2))
4273 dif = self.n_Muestras_p-(self.nro_key_p+self.f_a_p*(self.c_ped-2))
4274 self.c_ped = 1
4275 ##tmp = j
4276 ##print("tmp else",tmp)
4277 self.nro_key_p= self.f_a_p-dif
4278 iterador = self.nro_key_p
4279 ####print("iterador else",iterador)
4280 if diff_utc >1:
4281 ####print("FALTAN DATOS DEL PEDESTAL AMIGO WAIT")
4282 ####sleep(1)
4283 #aqui no hay DATA pero creo el nro_key_p "como si existiera" y reinicio el c_ped
4284 ####print("continua bro")
4285 ####print("self.c_ped",self.c_ped)
4286 dif = self.n_Muestras_p-(self.nro_key_p+self.f_a_p*(self.c_ped-2))
4287 self.c_ped = 1
4288 self.nro_key_p = self.f_a_p-dif
4289 #
4290 iterador = self.nro_key_p
4291 print("iterador else",iterador)
4292 #
4293 utc_ped_nofile = self.gettimeutcfromDirFilename(path=self.path_ped,file=self.list_pedestal[self.nro_file-1])+1
4294 #iterador = self.nro_key_p #no hay iterador pero importa el nro_key_p
4295 flag_NOPedfile= True
4296 print("q paso")
4297
4298 if diff_utc <0:
4299 print("No hay mas archivos")
4300 self.angulo_adq = numpy.ones(self.blocksPerfile)*numpy.nan
4301 else:
4302 print("NO EXISTE DATA - IMAGINA")
4303 dif = self.n_Muestras_p-(self.nro_key_p+self.f_a_p*(self.c_ped-2))
4304 self.c_ped = 1
4305 ##tmp = j
4306 ##print("tmp else",tmp)
4307 self.nro_key_p= self.f_a_p-dif
4308
4309
4310
4311
4312 if flag_NOPedfile == False:
4313 # AQUI NECESITO DOS COSAS "nro_file" y el "iterador"
4314 ff_pedestal = self.list_pedestal[self.nro_file]
4315 print("ff_pedestal",ff_pedestal)
4316 angulo = self.getDatavaluefromDirFilename(path=self.path_ped,file=ff_pedestal,value="azi_pos")
4317 save_angulo = angulo[iterador]
4318 self.angulo_adq[j]= angulo[iterador]
4319 else:
4320 print(" DATA SIMULADA------------------------------------",j)
4321 self.angulo_adq[j]= numpy.nan
4322 cont_NOPedFile = cont_NOPedFile + 1
4323 print("contador:",cont_NOPedFile)
4324 sleep(2)
4325 if cont_NOPedFile==self.f_a_p:
4326 cont_NOPedFile = 0
4327 utc_ped_nofile = utc_ped_nofile+1
4328 utc_ped_setnext= self.gettimeutcfromDirFilename(path=self.path_ped,file=self.list_pedestal[self.nro_file])
4329 if utc_ped_setnext-utc_ped_nofile==1:
4330 fladata_pg_NOPedfile=False
4331
4332
4333
4334
4335 return self.angulo_adq
4147 pass
4336 4148
4337 4149 def setNextFileonline(self):
4338 tmp = 0
4339 self.nTries_p = 3
4340 self.delay = 3
4341 ready = 1
4342 for j in range(self.blocksPerfile):
4343 iterador = self.nro_key_p +self.f_a_p*(j-tmp)
4344 if iterador < self.n_Muestras_p:
4345 self.nro_file = self.nro_file
4346 else:
4347 self.nro_file = self.nro_file+1
4348 dif = self.blocksPerfile-(self.nro_key_p+self.f_a_p*(j-tmp-1))
4349 tmp = j
4350 self.nro_key_p= self.f_a_p-dif
4351 iterador = self.nro_key_p
4352 #print("nro_file---------------- :",self.nro_file)
4353 try:
4354 # update list_pedestal
4355 self.list_pedestal = self.getfirstFilefromPath(path=self.path_ped,meta="PE",ext=".hdf5")
4356 ff_pedestal = self.list_pedestal[self.nro_file]
4357 except:
4358 ff_pedestal = None
4359 ready = 0
4360 for nTries_p in range(self.nTries_p):
4361 try:
4362 # update list_pedestal
4363 self.list_pedestal = self.getfirstFilefromPath(path=self.path_ped,meta="PE",ext=".hdf5")
4364 ff_pedestal = self.list_pedestal[self.nro_file]
4365 except:
4366 ff_pedestal = None
4367 if ff_pedestal is not None:
4368 ready=1
4369 break
4370 log.warning("Waiting %0.2f sec for the next file: \"%s\" , try %02d ..." % (self.delay, self.nro_file, nTries_p + 1))
4371 time.sleep(self.delay)
4372 continue
4373 #return numpy.ones(self.blocksPerfile)*numpy.nan
4150 pass
4374 4151
4375 if ready == 1:
4376 #angulo = self.getDatavaluefromDirFilename(path=self.path_ped,file=ff_pedestal,value="azimuth")
4377 angulo = self.getDatavaluefromDirFilename(path=self.path_ped,file=ff_pedestal,value="azi_pos")
4378
4379 else:
4380 print("there is no pedestal file")
4381 angulo = numpy.ones(self.n_Muestras_p)*numpy.nan
4382 self.angulo_adq[j]= angulo[iterador]
4383 ####print("Angulo",self.angulo_adq)
4384 ####print("Angulo",len(self.angulo_adq))
4385 #self.nro_key_p=iterador + self.f_a_p
4386 #if self.nro_key_p< self.n_Muestras_p:
4387 # self.nro_file = self.nro_file
4388 #else:
4389 # self.nro_file = self.nro_file+1
4390 # self.nro_key_p= self.nro_key_p
4391 return self.angulo_adq
4392
4393
4394 #def run(self, dataOut,path_ped,path_adq,t_Interval_p,n_Muestras_p,blocksPerfile,f_a_p,online):
4395 4152 def run(self, dataOut,path_ped,t_Interval_p,n_Muestras_p,blocksPerfile,f_a_p,online):
4396 4153 if not self.isConfig:
4397 4154 self.setup(dataOut, path_ped,t_Interval_p,n_Muestras_p,blocksPerfile,f_a_p,online)
4398 4155 self.__dataReady = True
4399 4156 self.isConfig = True
4400 4157 #print("config TRUE")
4401
4402 4158 utc_adq = dataOut.utctime
4403 4159 ####print("utc_adq---------------",utc_adq)
4404 4160 list_pedestal = self.list_pedestal
4405 4161 angulo = self.getAnguloProfile(utc_adq=utc_adq,list_pedestal=list_pedestal)
4406 4162 ####print("angulo**********",angulo)
4407 4163 dataOut.flagNoData = False
4408 4164 if numpy.isnan(angulo):
4409 4165 dataOut.flagNoData = True
4410 4166 return dataOut
4411 4167 dataOut.azimuth = angulo
4412 4168 return dataOut
4413 4169
4414 '''
4415 if not self.isConfig:
4416 print("######################SETUP#########################################")
4417 print("CONFIG dataOut.utctime---",dataOut.utctime)
4418 #self.setup( dataOut, path_ped,path_adq,t_Interval_p,n_Muestras_p,blocksPerfile,f_a_p,online)
4419 self.setup( dataOut, path_ped,t_Interval_p,n_Muestras_p,blocksPerfile,f_a_p,online)
4420 print("aqui bro")
4421 if self.nro_file>=0:
4422 self.isConfig = True
4423 else:
4424 self.isConfig = False
4425 print("RUN---dataOut.utctime---",dataOut.utctime)
4426
4427 dataOut.flagNoData = True
4428 #sleep(0.5)
4429 #print("--------------------------------------------------------------------------------")
4430 #print("profIndex",self.__profIndex)
4431 '''
4432 '''
4433 if self.__profIndex==0:
4434 angulo_adq = self.setNextFileP(dataOut)
4435 dataOut.azimuth = angulo_adq
4436 print("TIEMPO--------:",dataOut.utctime)
4437 print("####################################################################")
4438 ####print("angulos",dataOut.azimuth,len(dataOut.azimuth))
4439 self.__dataReady = True
4440 '''
4441 '''
4442 self.__profIndex += 1
4443 ####print("TIEMPO_bucle:",dataOut.utctime)
4444 #print("profIndex",self.__profIndex)
4445 if self.__profIndex== blocksPerfile:
4446 self.__dataReady = True
4447 self.__profIndex = 0
4448 if self.__dataReady:
4449 #print(self.__profIndex,dataOut.azimuth[:10])
4450 angulo_adq = self.setNextFileP(dataOut)
4451 dataOut.azimuth = angulo_adq
4452 print("TIEMPO--------:",dataOut.utctime)
4453 print("####################################################################")
4454 ####print("angulos",dataOut.azimuth,len(dataOut.azimuth))
4455 dataOut.flagNoData = False
4456 '''
4457 #return dataOut
4458
4459
4460 4170 class Block360(Operation):
4461 4171 '''
4462 4172 '''
4463 4173 isConfig = False
4464 4174 __profIndex = 0
4465 4175 __initime = None
4466 4176 __lastdatatime = None
4467 4177 __buffer = None
4468 4178 __dataReady = False
4469 4179 n = None
4470 4180 __nch = 0
4471 4181 __nHeis = 0
4472 4182 index = 0
4473 4183 mode = 0
4474 4184
4475 4185 def __init__(self,**kwargs):
4476 4186 Operation.__init__(self,**kwargs)
4477 4187
4478 4188 def setup(self, dataOut, n = None, mode = None):
4479 4189 '''
4480 4190 n= Numero de PRF's de entrada
4481 4191 '''
4482 4192 self.__initime = None
4483 4193 self.__lastdatatime = 0
4484 4194 self.__dataReady = False
4485 4195 self.__buffer = 0
4486 4196 self.__buffer_1D = 0
4487 4197 self.__profIndex = 0
4488 4198 self.index = 0
4489 4199 self.__nch = dataOut.nChannels
4490 4200 self.__nHeis = dataOut.nHeights
4491 4201 ##print("ELVALOR DE n es:", n)
4492 4202 if n == None:
4493 4203 raise ValueError("n should be specified.")
4494 4204
4495 4205 if mode == None:
4496 4206 raise ValueError("mode should be specified.")
4497 4207
4498 4208 if n != None:
4499 4209 if n<1:
4500 4210 print("n should be greater than 2")
4501 4211 raise ValueError("n should be greater than 2")
4502 4212
4503 4213 self.n = n
4504 4214 self.mode = mode
4505 4215 print("self.mode",self.mode)
4506 4216 #print("nHeights")
4507 4217 self.__buffer = numpy.zeros(( dataOut.nChannels,n, dataOut.nHeights))
4508 4218 self.__buffer2= numpy.zeros(n)
4509 4219
4510 4220 def putData(self,data,mode):
4511 4221 '''
4512 4222 Add a profile to he __buffer and increase in one the __profiel Index
4513 4223 '''
4514 4224 #print("line 4049",data.dataPP_POW.shape,data.dataPP_POW[:10])
4515 4225 #print("line 4049",data.azimuth.shape,data.azimuth)
4516 4226 if self.mode==0:
4517 4227 self.__buffer[:,self.__profIndex,:]= data.dataPP_POWER# PRIMER MOMENTO
4518 4228 if self.mode==1:
4519 4229 self.__buffer[:,self.__profIndex,:]= data.data_pow
4520 4230 #print("me casi",self.index,data.azimuth[self.index])
4521 4231 #print(self.__profIndex, self.index , data.azimuth[self.index] )
4522 4232 #print("magic",data.profileIndex)
4523 4233 #print(data.azimuth[self.index])
4524 4234 #print("index",self.index)
4525 4235
4526 4236 #####self.__buffer2[self.__profIndex] = data.azimuth[self.index]
4527 4237 self.__buffer2[self.__profIndex] = data.azimuth
4528 4238 #print("q pasa")
4529 4239 #####self.index+=1
4530 4240 #print("index",self.index,data.azimuth[:10])
4531 4241 self.__profIndex += 1
4532 4242 return #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Remove DCΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
4533 4243
4534 4244 def pushData(self,data):
4535 4245 '''
4536 4246 Return the PULSEPAIR and the profiles used in the operation
4537 4247 Affected : self.__profileIndex
4538 4248 '''
4539 4249 #print("pushData")
4540 4250
4541 4251 data_360 = self.__buffer
4542 4252 data_p = self.__buffer2
4543 4253 n = self.__profIndex
4544 4254
4545 4255 self.__buffer = numpy.zeros((self.__nch, self.n,self.__nHeis))
4546 4256 self.__buffer2 = numpy.zeros(self.n)
4547 4257 self.__profIndex = 0
4548 4258 #print("pushData")
4549 4259 return data_360,n,data_p
4550 4260
4551 4261
4552 4262 def byProfiles(self,dataOut):
4553 4263
4554 4264 self.__dataReady = False
4555 4265 data_360 = None
4556 4266 data_p = None
4557 4267 #print("dataOu",dataOut.dataPP_POW)
4558 4268 self.putData(data=dataOut,mode = self.mode)
4559 4269 ##### print("profIndex",self.__profIndex)
4560 4270 if self.__profIndex == self.n:
4561 4271 data_360,n,data_p = self.pushData(data=dataOut)
4562 4272 self.__dataReady = True
4563 4273
4564 4274 return data_360,data_p
4565 4275
4566 4276
4567 4277 def blockOp(self, dataOut, datatime= None):
4568 4278 if self.__initime == None:
4569 4279 self.__initime = datatime
4570 4280 data_360,data_p = self.byProfiles(dataOut)
4571 4281 self.__lastdatatime = datatime
4572 4282
4573 4283 if data_360 is None:
4574 4284 return None, None,None
4575 4285
4576 4286
4577 4287 avgdatatime = self.__initime
4578 4288 if self.n==1:
4579 4289 avgdatatime = datatime
4580 4290 deltatime = datatime - self.__lastdatatime
4581 4291 self.__initime = datatime
4582 4292 #print(data_360.shape,avgdatatime,data_p.shape)
4583 4293 return data_360,avgdatatime,data_p
4584 4294
4585 4295 def run(self, dataOut,n = None,mode=None,**kwargs):
4586 4296 #print("BLOCK 360 HERE WE GO MOMENTOS")
4587 4297 if not self.isConfig:
4588 4298 self.setup(dataOut = dataOut, n = n ,mode= mode ,**kwargs)
4589 4299 ####self.index = 0
4590 4300 #print("comova",self.isConfig)
4591 4301 self.isConfig = True
4592 4302 ####if self.index==dataOut.azimuth.shape[0]:
4593 4303 #### self.index=0
4594 4304 data_360, avgdatatime,data_p = self.blockOp(dataOut, dataOut.utctime)
4595 4305 dataOut.flagNoData = True
4596 4306
4597 4307 if self.__dataReady:
4598 4308 dataOut.data_360 = data_360 # S
4599 4309 ##print("---------------------------------------------------------------------------------")
4600 4310 #####print("---------------------------DATAREADY---------------------------------------------")
4601 4311 ##print("---------------------------------------------------------------------------------")
4602 4312 ##print("data_360",dataOut.data_360.shape)
4603 4313 dataOut.data_azi = data_p
4604 4314 #####print("azi: ",dataOut.data_azi)
4605 4315 #print("jroproc_parameters",data_p[0],data_p[-1])#,data_360.shape,avgdatatime)
4606 4316 dataOut.utctime = avgdatatime
4607 4317 dataOut.flagNoData = False
4608 4318 return dataOut
General Comments 0
You need to be logged in to leave comments. Login now