##// END OF EJS Templates
schain
RSS
Bug Fixed: Index List for AMISR Beams ...
Daniel Valdez -
r504:1f121b011372
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,607 +1,612
1 1 import os
2 2 import numpy
3 3 import time, datetime
4 4 import mpldriver
5 5
6 6
7 7 import Queue
8 8 import threading
9 9
10 10 def isRealtime(utcdatatime):
11 11 utcnow = time.mktime(time.localtime())
12 12 delta = abs(utcnow - utcdatatime) # abs
13 13 if delta >= 30.:
14 14 return False
15 15 return True
16 16
17 17
18 18
19 19
20 20 class Figure:
21 21
22 22 __driver = mpldriver
23 23 __isConfigThread = False
24 24 fig = None
25 25
26 26 id = None
27 27 wintitle = None
28 28 width = None
29 29 height = None
30 30 nplots = None
31 31 timerange = None
32 32
33 33 axesObjList = []
34 34
35 35 WIDTH = None
36 36 HEIGHT = None
37 37 PREFIX = 'fig'
38 38
39 39 xmin = None
40 40 xmax = None
41 41
42 42 def __init__(self):
43 43
44 44 raise ValueError, "This method is not implemented"
45 45
46 46 def __del__(self):
47 47
48 48 self.__driver.closeFigure()
49 49
50 50 def getFilename(self, name, ext='.png'):
51 51
52 52 path = '%s%03d' %(self.PREFIX, self.id)
53 53 filename = '%s_%s%s' %(self.PREFIX, name, ext)
54 54 return os.path.join(path, filename)
55 55
56 56 def getAxesObjList(self):
57 57
58 58 return self.axesObjList
59 59
60 60 def getSubplots(self):
61 61
62 62 raise ValueError, "Abstract method: This method should be defined"
63 63
64 64 def getScreenDim(self, widthplot, heightplot):
65 65
66 66 nrow, ncol = self.getSubplots()
67 67
68 68 widthscreen = widthplot*ncol
69 69 heightscreen = heightplot*nrow
70 70
71 71 return widthscreen, heightscreen
72 72
73 73 def getTimeLim(self, x, xmin=None, xmax=None, timerange=None):
74 74
75 if self.xmin != None and self.xmax != None:
75 if xmin != None and xmax != None:
76 76 if timerange == None:
77 timerange = self.xmax - self.xmin
78 xmin = self.xmin + timerange
79 xmax = self.xmax + timerange
77 timerange = xmax - xmin
78 xmin = xmin + timerange
79 xmax = xmax + timerange
80 80
81 81 return xmin, xmax
82 82
83 83
84 if timerange != None and self.xmin == None and self.xmax == None:
84 if timerange != None and xmin == None and xmax == None:
85 85 txmin = x[0] - x[0]%timerange
86 else:
87 txmin = numpy.min(x)
88 timerange = 60*60*2
89
90 if xmin == None and xmax == None:
86 91 thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
87 92 thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
88 93 xmin = (thisdatetime - thisdate).seconds/(60*60.)
89 94 xmax = xmin + timerange/(60*60.)
90 95
91 96
92 97 if timerange == None:
93 txmin = numpy.min(x)
98
94 99 thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
95 100 thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
96 101
97 102 mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
98 103 xmin_sec = time.mktime(mindt.timetuple())
99 104
100 105 maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
101 106 xmax_sec = time.mktime(maxdt.timetuple())
102 107
103 108 return xmin_sec, xmax_sec
104 109
105 110
106 111
107 112
108 113
109 114 # if timerange != None:
110 115 # txmin = x[0] - x[0]%timerange
111 116 # else:
112 117 # txmin = numpy.min(x)
113 118 #
114 119 # thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
115 120 # thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
116 121 #
117 122 # ####################################################
118 123 # #If the x is out of xrange
119 124 # if xmax != None:
120 125 # if xmax < (thisdatetime - thisdate).seconds/(60*60.):
121 126 # xmin = None
122 127 # xmax = None
123 128 #
124 129 # if xmin == None:
125 130 # td = thisdatetime - thisdate
126 131 # xmin = td.seconds/(60*60.)
127 132 #
128 133 # if xmax == None:
129 134 # xmax = xmin + self.timerange/(60*60.)
130 135 #
131 136 # mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
132 137 # tmin = time.mktime(mindt.timetuple())
133 138 #
134 139 # maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
135 140 # tmax = time.mktime(maxdt.timetuple())
136 141 #
137 142 # #self.timerange = tmax - tmin
138 143 #
139 144 # return tmin, tmax
140 145
141 146 def init(self, id, nplots, wintitle):
142 147
143 148 raise ValueError, "This method has been replaced with createFigure"
144 149
145 150 def createFigure(self, id, wintitle, widthplot=None, heightplot=None, show=True):
146 151
147 152 """
148 153 Crea la figura de acuerdo al driver y parametros seleccionados seleccionados.
149 154 Las dimensiones de la pantalla es calculada a partir de los atributos self.WIDTH
150 155 y self.HEIGHT y el numero de subplots (nrow, ncol)
151 156
152 157 Input:
153 158 id : Los parametros necesarios son
154 159 wintitle :
155 160
156 161 """
157 162
158 163 if widthplot == None:
159 164 widthplot = self.WIDTH
160 165
161 166 if heightplot == None:
162 167 heightplot = self.HEIGHT
163 168
164 169 self.id = id
165 170
166 171 self.wintitle = wintitle
167 172
168 173 self.widthscreen, self.heightscreen = self.getScreenDim(widthplot, heightplot)
169 174
170 175 self.fig = self.__driver.createFigure(id=self.id,
171 176 wintitle=self.wintitle,
172 177 width=self.widthscreen,
173 178 height=self.heightscreen,
174 179 show=show)
175 180
176 181 self.axesObjList = []
177 182
178 183
179 184 def setDriver(self, driver=mpldriver):
180 185
181 186 self.__driver = driver
182 187
183 188 def setTitle(self, title):
184 189
185 190 self.__driver.setTitle(self.fig, title)
186 191
187 192 def setWinTitle(self, title):
188 193
189 194 self.__driver.setWinTitle(self.fig, title=title)
190 195
191 196 def setTextFromAxes(self, text):
192 197
193 198 raise ValueError, "Este metodo ha sido reemplazaado con el metodo setText de la clase Axes"
194 199
195 200 def makeAxes(self, nrow, ncol, xpos, ypos, colspan, rowspan):
196 201
197 202 raise ValueError, "Este metodo ha sido reemplazaado con el metodo addAxes"
198 203
199 204 def addAxes(self, *args):
200 205 """
201 206
202 207 Input:
203 208 *args : Los parametros necesarios son
204 209 nrow, ncol, xpos, ypos, colspan, rowspan
205 210 """
206 211
207 212 axesObj = Axes(self.fig, *args)
208 213 self.axesObjList.append(axesObj)
209 214
210 215 def saveFigure(self, figpath, figfile, *args):
211 216
212 217 filename = os.path.join(figpath, figfile)
213 218
214 219 fullpath = os.path.split(filename)[0]
215 220
216 221 if not os.path.exists(fullpath):
217 222 subpath = os.path.split(fullpath)[0]
218 223
219 224 if not os.path.exists(subpath):
220 225 os.mkdir(subpath)
221 226
222 227 os.mkdir(fullpath)
223 228
224 229 self.__driver.saveFigure(self.fig, filename, *args)
225 230
226 231
227 232
228 233
229 234 def getNameToFtp(self, thisDatetime, FTP_WEI, EXP_CODE, SUB_EXP_CODE, PLOT_CODE, PLOT_POS):
230 235 YEAR_STR = '%4.4d'%thisDatetime.timetuple().tm_year
231 236 DOY_STR = '%3.3d'%thisDatetime.timetuple().tm_yday
232 237 FTP_WEI = '%2.2d'%FTP_WEI
233 238 EXP_CODE = '%3.3d'%EXP_CODE
234 239 SUB_EXP_CODE = '%2.2d'%SUB_EXP_CODE
235 240 PLOT_CODE = '%2.2d'%PLOT_CODE
236 241 PLOT_POS = '%2.2d'%PLOT_POS
237 242 name = YEAR_STR + DOY_STR + FTP_WEI + EXP_CODE + SUB_EXP_CODE + PLOT_CODE + PLOT_POS
238 243 return name
239 244
240 245 def draw(self):
241 246
242 247 self.__driver.draw(self.fig)
243 248
244 249 def run(self):
245 250
246 251 raise ValueError, "This method is not implemented"
247 252
248 253 def close(self):
249 254
250 255 self.__driver.show(True)
251 256
252 257 axesList = property(getAxesObjList)
253 258
254 259
255 260 class Axes:
256 261
257 262 __driver = mpldriver
258 263 fig = None
259 264 ax = None
260 265 plot = None
261 266 __missing = 1E30
262 267 __firsttime = None
263 268
264 269 __showprofile = False
265 270
266 271 xmin = None
267 272 xmax = None
268 273 ymin = None
269 274 ymax = None
270 275 zmin = None
271 276 zmax = None
272 277
273 278 x_buffer = None
274 279 z_buffer = None
275 280
276 281 decimationx = None
277 282 decimationy = None
278 283
279 284 __MAXNUMX = 300
280 285 __MAXNUMY = 150
281 286
282 287 def __init__(self, *args):
283 288
284 289 """
285 290
286 291 Input:
287 292 *args : Los parametros necesarios son
288 293 fig, nrow, ncol, xpos, ypos, colspan, rowspan
289 294 """
290 295
291 296 ax = self.__driver.createAxes(*args)
292 297 self.fig = args[0]
293 298 self.ax = ax
294 299 self.plot = None
295 300
296 301 self.__firsttime = True
297 302 self.idlineList = []
298 303
299 304 self.x_buffer = numpy.array([])
300 305 self.z_buffer = numpy.array([])
301 306
302 307 def setText(self, text):
303 308
304 309 self.__driver.setAxesText(self.ax, text)
305 310
306 311 def setXAxisAsTime(self):
307 312 pass
308 313
309 314 def pline(self, x, y,
310 315 xmin=None, xmax=None,
311 316 ymin=None, ymax=None,
312 317 xlabel='', ylabel='',
313 318 title='',
314 319 **kwargs):
315 320
316 321 """
317 322
318 323 Input:
319 324 x :
320 325 y :
321 326 xmin :
322 327 xmax :
323 328 ymin :
324 329 ymax :
325 330 xlabel :
326 331 ylabel :
327 332 title :
328 333 **kwargs : Los parametros aceptados son
329 334
330 335 ticksize
331 336 ytick_visible
332 337 """
333 338
334 339 if self.__firsttime:
335 340
336 341 if xmin == None: xmin = numpy.nanmin(x)
337 342 if xmax == None: xmax = numpy.nanmax(x)
338 343 if ymin == None: ymin = numpy.nanmin(y)
339 344 if ymax == None: ymax = numpy.nanmax(y)
340 345
341 346 self.plot = self.__driver.createPline(self.ax, x, y,
342 347 xmin, xmax,
343 348 ymin, ymax,
344 349 xlabel=xlabel,
345 350 ylabel=ylabel,
346 351 title=title,
347 352 **kwargs)
348 353
349 354 self.idlineList.append(0)
350 355 self.__firsttime = False
351 356 return
352 357
353 358 self.__driver.pline(self.plot, x, y, xlabel=xlabel,
354 359 ylabel=ylabel,
355 360 title=title)
356 361
357 362 def addpline(self, x, y, idline, **kwargs):
358 363 lines = self.ax.lines
359 364
360 365 if idline in self.idlineList:
361 366 self.__driver.set_linedata(self.ax, x, y, idline)
362 367
363 368 if idline not in(self.idlineList):
364 369 self.__driver.addpline(self.ax, x, y, **kwargs)
365 370 self.idlineList.append(idline)
366 371
367 372 return
368 373
369 374 def pmultiline(self, x, y,
370 375 xmin=None, xmax=None,
371 376 ymin=None, ymax=None,
372 377 xlabel='', ylabel='',
373 378 title='',
374 379 **kwargs):
375 380
376 381 if self.__firsttime:
377 382
378 383 if xmin == None: xmin = numpy.nanmin(x)
379 384 if xmax == None: xmax = numpy.nanmax(x)
380 385 if ymin == None: ymin = numpy.nanmin(y)
381 386 if ymax == None: ymax = numpy.nanmax(y)
382 387
383 388 self.plot = self.__driver.createPmultiline(self.ax, x, y,
384 389 xmin, xmax,
385 390 ymin, ymax,
386 391 xlabel=xlabel,
387 392 ylabel=ylabel,
388 393 title=title,
389 394 **kwargs)
390 395 self.__firsttime = False
391 396 return
392 397
393 398 self.__driver.pmultiline(self.plot, x, y, xlabel=xlabel,
394 399 ylabel=ylabel,
395 400 title=title)
396 401
397 402 def pmultilineyaxis(self, x, y,
398 403 xmin=None, xmax=None,
399 404 ymin=None, ymax=None,
400 405 xlabel='', ylabel='',
401 406 title='',
402 407 **kwargs):
403 408
404 409 if self.__firsttime:
405 410
406 411 if xmin == None: xmin = numpy.nanmin(x)
407 412 if xmax == None: xmax = numpy.nanmax(x)
408 413 if ymin == None: ymin = numpy.nanmin(y)
409 414 if ymax == None: ymax = numpy.nanmax(y)
410 415
411 416 self.plot = self.__driver.createPmultilineYAxis(self.ax, x, y,
412 417 xmin, xmax,
413 418 ymin, ymax,
414 419 xlabel=xlabel,
415 420 ylabel=ylabel,
416 421 title=title,
417 422 **kwargs)
418 423 if self.xmin == None: self.xmin = xmin
419 424 if self.xmax == None: self.xmax = xmax
420 425 if self.ymin == None: self.ymin = ymin
421 426 if self.ymax == None: self.ymax = ymax
422 427
423 428 self.__firsttime = False
424 429 return
425 430
426 431 self.__driver.pmultilineyaxis(self.plot, x, y, xlabel=xlabel,
427 432 ylabel=ylabel,
428 433 title=title)
429 434
430 435 def pcolor(self, x, y, z,
431 436 xmin=None, xmax=None,
432 437 ymin=None, ymax=None,
433 438 zmin=None, zmax=None,
434 439 xlabel='', ylabel='',
435 440 title='', rti = False, colormap='jet',
436 441 **kwargs):
437 442
438 443 """
439 444 Input:
440 445 x :
441 446 y :
442 447 x :
443 448 xmin :
444 449 xmax :
445 450 ymin :
446 451 ymax :
447 452 zmin :
448 453 zmax :
449 454 xlabel :
450 455 ylabel :
451 456 title :
452 457 **kwargs : Los parametros aceptados son
453 458 ticksize=9,
454 459 cblabel=''
455 460 rti = True or False
456 461 """
457 462
458 463 if self.__firsttime:
459 464
460 465 if xmin == None: xmin = numpy.nanmin(x)
461 466 if xmax == None: xmax = numpy.nanmax(x)
462 467 if ymin == None: ymin = numpy.nanmin(y)
463 468 if ymax == None: ymax = numpy.nanmax(y)
464 469 if zmin == None: zmin = numpy.nanmin(z)
465 470 if zmax == None: zmax = numpy.nanmax(z)
466 471
467 472
468 473 self.plot = self.__driver.createPcolor(self.ax, x, y, z,
469 474 xmin, xmax,
470 475 ymin, ymax,
471 476 zmin, zmax,
472 477 xlabel=xlabel,
473 478 ylabel=ylabel,
474 479 title=title,
475 480 colormap=colormap,
476 481 **kwargs)
477 482
478 483 if self.xmin == None: self.xmin = xmin
479 484 if self.xmax == None: self.xmax = xmax
480 485 if self.ymin == None: self.ymin = ymin
481 486 if self.ymax == None: self.ymax = ymax
482 487 if self.zmin == None: self.zmin = zmin
483 488 if self.zmax == None: self.zmax = zmax
484 489
485 490 self.__firsttime = False
486 491 return
487 492
488 493 if rti:
489 494 self.__driver.addpcolor(self.ax, x, y, z, self.zmin, self.zmax,
490 495 xlabel=xlabel,
491 496 ylabel=ylabel,
492 497 title=title,
493 498 colormap=colormap)
494 499 return
495 500
496 501 self.__driver.pcolor(self.plot, z,
497 502 xlabel=xlabel,
498 503 ylabel=ylabel,
499 504 title=title)
500 505
501 506 def pcolorbuffer(self, x, y, z,
502 507 xmin=None, xmax=None,
503 508 ymin=None, ymax=None,
504 509 zmin=None, zmax=None,
505 510 xlabel='', ylabel='',
506 511 title='', rti = True, colormap='jet',
507 512 maxNumX = None, maxNumY = None,
508 513 **kwargs):
509 514
510 515 if maxNumX == None:
511 516 maxNumX = self.__MAXNUMX
512 517
513 518 if maxNumY == None:
514 519 maxNumY = self.__MAXNUMY
515 520
516 521 if self.__firsttime:
517 522 self.z_buffer = z
518 523 self.x_buffer = numpy.hstack((self.x_buffer, x))
519 524
520 525 if xmin == None: xmin = numpy.nanmin(x)
521 526 if xmax == None: xmax = numpy.nanmax(x)
522 527 if ymin == None: ymin = numpy.nanmin(y)
523 528 if ymax == None: ymax = numpy.nanmax(y)
524 529 if zmin == None: zmin = numpy.nanmin(z)
525 530 if zmax == None: zmax = numpy.nanmax(z)
526 531
527 532
528 533 self.plot = self.__driver.createPcolor(self.ax, self.x_buffer, y, z,
529 534 xmin, xmax,
530 535 ymin, ymax,
531 536 zmin, zmax,
532 537 xlabel=xlabel,
533 538 ylabel=ylabel,
534 539 title=title,
535 540 colormap=colormap,
536 541 **kwargs)
537 542
538 543 if self.xmin == None: self.xmin = xmin
539 544 if self.xmax == None: self.xmax = xmax
540 545 if self.ymin == None: self.ymin = ymin
541 546 if self.ymax == None: self.ymax = ymax
542 547 if self.zmin == None: self.zmin = zmin
543 548 if self.zmax == None: self.zmax = zmax
544 549
545 550 self.__firsttime = False
546 551 return
547 552
548 553 self.x_buffer = numpy.hstack((self.x_buffer, x[-1]))
549 554 self.z_buffer = numpy.hstack((self.z_buffer, z))
550 555
551 556 if self.decimationx == None:
552 557 deltax = float(self.xmax - self.xmin)/maxNumX
553 558 deltay = float(self.ymax - self.ymin)/maxNumY
554 559
555 560 resolutionx = self.x_buffer[2]-self.x_buffer[0]
556 561 resolutiony = y[1]-y[0]
557 562
558 563 self.decimationx = numpy.ceil(deltax / resolutionx)
559 564 self.decimationy = numpy.ceil(deltay / resolutiony)
560 565
561 566 z_buffer = self.z_buffer.reshape(-1,len(y))
562 567
563 568 x_buffer = self.x_buffer[::self.decimationx]
564 569 y_buffer = y[::self.decimationy]
565 570 z_buffer = z_buffer[::self.decimationx, ::self.decimationy]
566 571 #===================================================
567 572
568 573 x_buffer, y_buffer, z_buffer = self.__fillGaps(x_buffer, y_buffer, z_buffer)
569 574
570 575 self.__driver.addpcolorbuffer(self.ax, x_buffer, y_buffer, z_buffer, self.zmin, self.zmax,
571 576 xlabel=xlabel,
572 577 ylabel=ylabel,
573 578 title=title,
574 579 colormap=colormap)
575 580
576 581 def polar(self, x, y,
577 582 title='', xlabel='',ylabel='',**kwargs):
578 583
579 584 if self.__firsttime:
580 585 self.plot = self.__driver.createPolar(self.ax, x, y, title = title, xlabel = xlabel, ylabel = ylabel)
581 586 self.__firsttime = False
582 587 self.x_buffer = x
583 588 self.y_buffer = y
584 589 return
585 590
586 591 self.x_buffer = numpy.hstack((self.x_buffer,x))
587 592 self.y_buffer = numpy.hstack((self.y_buffer,y))
588 593 self.__driver.polar(self.plot, self.x_buffer, self.y_buffer, xlabel=xlabel,
589 594 ylabel=ylabel,
590 595 title=title)
591 596
592 597 def __fillGaps(self, x_buffer, y_buffer, z_buffer):
593 598
594 599 deltas = x_buffer[1:] - x_buffer[0:-1]
595 600 x_median = numpy.median(deltas)
596 601
597 602 index = numpy.where(deltas >= 2*x_median)
598 603
599 604 if len(index[0]) != 0:
600 605 z_buffer[index[0],::] = self.__missing
601 606 z_buffer = numpy.ma.masked_inside(z_buffer,0.99*self.__missing,1.01*self.__missing)
602 607
603 608 return x_buffer, y_buffer, z_buffer
604 609
605 610
606 611
607 612 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,617 +1,619
1 1 '''
2 2 @author: Daniel Suarez
3 3 '''
4 4
5 5 import os
6 6 import sys
7 7 import glob
8 8 import fnmatch
9 9 import datetime
10 10 import time
11 11 import re
12 12 import h5py
13 13 import numpy
14 14
15 15 from model.proc.jroproc_base import ProcessingUnit, Operation
16 16 from model.data.jroamisr import AMISR
17 17
18 18 class RadacHeader():
19 19 def __init__(self, fp):
20 20 header = 'Raw11/Data/RadacHeader'
21 21 self.beamCodeByPulse = fp.get(header+'/BeamCode')
22 22 self.beamCode = fp.get('Raw11/Data/Beamcodes')
23 23 self.code = fp.get(header+'/Code')
24 24 self.frameCount = fp.get(header+'/FrameCount')
25 25 self.modeGroup = fp.get(header+'/ModeGroup')
26 26 self.nsamplesPulse = fp.get(header+'/NSamplesPulse')
27 27 self.pulseCount = fp.get(header+'/PulseCount')
28 28 self.radacTime = fp.get(header+'/RadacTime')
29 29 self.timeCount = fp.get(header+'/TimeCount')
30 30 self.timeStatus = fp.get(header+'/TimeStatus')
31 31
32 32 self.nrecords = self.pulseCount.shape[0] #nblocks
33 33 self.npulses = self.pulseCount.shape[1] #nprofile
34 34 self.nsamples = self.nsamplesPulse[0,0] #ngates
35 35 self.nbeams = self.beamCode.shape[1]
36 36
37 37
38 38 def getIndexRangeToPulse(self, idrecord=0):
39 39 #indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)
40 40 #startPulseCountId = indexToZero[0][0]
41 41 #endPulseCountId = startPulseCountId - 1
42 42 #range1 = numpy.arange(startPulseCountId,self.npulses,1)
43 43 #range2 = numpy.arange(0,startPulseCountId,1)
44 44 #return range1, range2
45 45
46 46 looking_zeros_index = numpy.where(self.pulseCount.value[idrecord,:]==0)[0]
47 47 getLastIndexZero = looking_zeros_index[-1]
48 48 index_data = numpy.arange(0,getLastIndexZero,1)
49 49 index_buffer = numpy.arange(getLastIndexZero,self.npulses,1)
50 50 return index_data, index_buffer
51 51
52 52 class AMISRReader(ProcessingUnit):
53 53
54 54 path = None
55 55 startDate = None
56 56 endDate = None
57 57 startTime = None
58 58 endTime = None
59 59 walk = None
60 60 isConfig = False
61 61
62 62 def __init__(self):
63 63 self.set = None
64 64 self.subset = None
65 65 self.extension_file = '.h5'
66 66 self.dtc_str = 'dtc'
67 67 self.dtc_id = 0
68 68 self.status = True
69 69 self.isConfig = False
70 70 self.dirnameList = []
71 71 self.filenameList = []
72 72 self.fileIndex = None
73 73 self.flagNoMoreFiles = False
74 74 self.flagIsNewFile = 0
75 75 self.filename = ''
76 76 self.amisrFilePointer = None
77 77 self.radacHeaderObj = None
78 78 self.dataOut = self.__createObjByDefault()
79 79 self.datablock = None
80 80 self.rest_datablock = None
81 81 self.range = None
82 82 self.idrecord_count = 0
83 83 self.profileIndex = 0
84 84 self.index_amisr_sample = None
85 85 self.index_amisr_buffer = None
86 86 self.beamCodeByFrame = None
87 87 self.radacTimeByFrame = None
88 88 #atributos originales tal y como esta en el archivo de datos
89 89 self.beamCodesFromFile = None
90 90 self.radacTimeFromFile = None
91 91 self.rangeFromFile = None
92 92 self.dataByFrame = None
93 93 self.dataset = None
94 94
95 95 self.beamCodeDict = {}
96 96 self.beamRangeDict = {}
97 97
98 98 #experiment cgf file
99 99 self.npulsesint_fromfile = None
100 100 self.recordsperfile_fromfile = None
101 101 self.nbeamcodes_fromfile = None
102 102 self.ngates_fromfile = None
103 103 self.ippSeconds_fromfile = None
104 104 self.frequency_h5file = None
105 105
106 106
107 107 self.__firstFile = True
108 108 self.buffer_radactime = None
109 109
110 110 self.index4_schain_datablock = None
111 111 self.index4_buffer = None
112 112 self.schain_datablock = None
113 113 self.buffer = None
114 114 self.linear_pulseCount = None
115 115 self.npulseByFrame = None
116 116 self.profileIndex_offset = None
117 117 self.timezone = 'ut'
118 118
119 119 def __createObjByDefault(self):
120 120
121 121 dataObj = AMISR()
122 122
123 123 return dataObj
124 124
125 125 def __setParameters(self,path,startDate,endDate,startTime,endTime,walk):
126 126 self.path = path
127 127 self.startDate = startDate
128 128 self.endDate = endDate
129 129 self.startTime = startTime
130 130 self.endTime = endTime
131 131 self.walk = walk
132 132
133 133 def __checkPath(self):
134 134 if os.path.exists(self.path):
135 135 self.status = 1
136 136 else:
137 137 self.status = 0
138 138 print 'Path:%s does not exists'%self.path
139 139
140 140 return
141 141
142 142 def __selDates(self, amisr_dirname_format):
143 143 try:
144 144 year = int(amisr_dirname_format[0:4])
145 145 month = int(amisr_dirname_format[4:6])
146 146 dom = int(amisr_dirname_format[6:8])
147 147 thisDate = datetime.date(year,month,dom)
148 148
149 149 if (thisDate>=self.startDate and thisDate <= self.endDate):
150 150 return amisr_dirname_format
151 151 except:
152 152 return None
153 153
154 154 def __findDataForDates(self):
155 155
156 156
157 157
158 158 if not(self.status):
159 159 return None
160 160
161 161 pat = '\d+.\d+'
162 162 dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
163 163 dirnameList = filter(lambda x:x!=None,dirnameList)
164 164 dirnameList = [x.string for x in dirnameList]
165 165 dirnameList = [self.__selDates(x) for x in dirnameList]
166 166 dirnameList = filter(lambda x:x!=None,dirnameList)
167 167 if len(dirnameList)>0:
168 168 self.status = 1
169 169 self.dirnameList = dirnameList
170 170 self.dirnameList.sort()
171 171 else:
172 172 self.status = 0
173 173 return None
174 174
175 175 def __getTimeFromData(self):
176 176 startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
177 177 endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
178 178
179 179 print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader)
180 180 print '........................................'
181 181 filter_filenameList = []
182 self.filenameList.sort()
182 183 for i in range(len(self.filenameList)-1):
183 184 filename = self.filenameList[i]
184 185 fp = h5py.File(filename,'r')
185 186 time_str = fp.get('Time/RadacTimeString')
186 187
187 188 startDateTimeStr_File = time_str[0][0].split('.')[0]
188 189 junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
189 190 startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
190 191
191 192 endDateTimeStr_File = time_str[-1][-1].split('.')[0]
192 193 junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
193 194 endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
194 195
195 196 fp.close()
196 197
197 198 if self.timezone == 'lt':
198 199 startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
199 200 endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300)
200 201
201 202 if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader):
202 203 #self.filenameList.remove(filename)
203 204 filter_filenameList.append(filename)
204 205
205 206 filter_filenameList.sort()
206 207 self.filenameList = filter_filenameList
207 208 return 1
208 209
209 210 def __filterByGlob1(self, dirName):
210 211 filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)
211 212 filterDict = {}
212 213 filterDict.setdefault(dirName)
213 214 filterDict[dirName] = filter_files
214 215 return filterDict
215 216
216 217 def __getFilenameList(self, fileListInKeys, dirList):
217 218 for value in fileListInKeys:
218 219 dirName = value.keys()[0]
219 220 for file in value[dirName]:
220 221 filename = os.path.join(dirName, file)
221 222 self.filenameList.append(filename)
222 223
223 224
224 225 def __selectDataForTimes(self):
225 226 #aun no esta implementado el filtro for tiempo
226 227 if not(self.status):
227 228 return None
228 229
229 230 dirList = [os.path.join(self.path,x) for x in self.dirnameList]
230 231
231 232 fileListInKeys = [self.__filterByGlob1(x) for x in dirList]
232 233
233 234 self.__getFilenameList(fileListInKeys, dirList)
234 235 #filtro por tiempo
235 236 if not(self.all):
236 237 self.__getTimeFromData()
237 238
238 239
239 240 if len(self.filenameList)>0:
240 241 self.status = 1
241 242 self.filenameList.sort()
242 243 else:
243 244 self.status = 0
244 245 return None
245 246
246 247
247 248 def __searchFilesOffline(self,
248 249 path,
249 250 startDate,
250 251 endDate,
251 252 startTime=datetime.time(0,0,0),
252 253 endTime=datetime.time(23,59,59),
253 254 walk=True):
254 255
255 256 self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
256 257
257 258 self.__checkPath()
258 259
259 260 self.__findDataForDates()
260 261
261 262 self.__selectDataForTimes()
262 263
263 264 for i in range(len(self.filenameList)):
264 265 print "%s" %(self.filenameList[i])
265 266
266 267 return
267 268
268 269 def __setNextFileOffline(self):
269 270 idFile = self.fileIndex
270 271
271 272 while (True):
272 273 idFile += 1
273 274 if not(idFile < len(self.filenameList)):
274 275 self.flagNoMoreFiles = 1
275 276 print "No more Files"
276 277 return 0
277 278
278 279 filename = self.filenameList[idFile]
279 280
280 281 amisrFilePointer = h5py.File(filename,'r')
281 282
282 283 break
283 284
284 285 self.flagIsNewFile = 1
285 286 self.fileIndex = idFile
286 287 self.filename = filename
287 288
288 289 self.amisrFilePointer = amisrFilePointer
289 290
290 291 print "Setting the file: %s"%self.filename
291 292
292 293 return 1
293 294
294 295 def __readHeader(self):
295 296 self.radacHeaderObj = RadacHeader(self.amisrFilePointer)
296 297
297 298 #update values from experiment cfg file
298 299 if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile:
299 300 self.radacHeaderObj.nrecords = self.recordsperfile_fromfile
300 301 self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile
301 302 self.radacHeaderObj.npulses = self.npulsesint_fromfile
302 303 self.radacHeaderObj.nsamples = self.ngates_fromfile
303 304
304 305 #looking index list for data
305 306 start_index = self.radacHeaderObj.pulseCount[0,:][0]
306 307 end_index = self.radacHeaderObj.npulses
307 308 range4data = range(start_index, end_index)
308 309 self.index4_schain_datablock = numpy.array(range4data)
309 310
310 311 buffer_start_index = 0
311 312 buffer_end_index = self.radacHeaderObj.pulseCount[0,:][0]
312 313 range4buffer = range(buffer_start_index, buffer_end_index)
313 314 self.index4_buffer = numpy.array(range4buffer)
314 315
315 316 self.linear_pulseCount = numpy.array(range4data + range4buffer)
316 317 self.npulseByFrame = max(self.radacHeaderObj.pulseCount[0,:]+1)
317 318
318 319 #get tuning frequency
319 320 frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency')
320 321 self.frequency_h5file = frequency_h5file_dataset[0,0]
321 322
322 323 self.flagIsNewFile = 1
323 324
324 325 def __getBeamCode(self):
325 326 self.beamCodeDict = {}
326 327 self.beamRangeDict = {}
327 328
328 329 beamCodeMap = self.amisrFilePointer.get('Setup/BeamcodeMap')
329 330
330 331 for i in range(len(self.radacHeaderObj.beamCode[0,:])):
331 332 self.beamCodeDict.setdefault(i)
332 333 self.beamRangeDict.setdefault(i)
333 334 beamcodeValue = self.radacHeaderObj.beamCode[0,i]
334 335 beamcodeIndex = numpy.where(beamCodeMap[:,0] == beamcodeValue)[0][0]
335 336 x = beamCodeMap[beamcodeIndex][1]
336 337 y = beamCodeMap[beamcodeIndex][2]
337 338 z = beamCodeMap[beamcodeIndex][3]
338 339 self.beamCodeDict[i] = [beamcodeValue, x, y, z]
339 340
340 341 just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:]
341 342
342 343 for i in range(len(self.beamCodeDict.values())):
343 344 xx = numpy.where(just4record0==self.beamCodeDict.values()[i][0])
344 self.beamRangeDict[i] = xx[0]
345 indexPulseByBeam = self.linear_pulseCount[xx[0]]
346 self.beamRangeDict[i] = indexPulseByBeam
345 347
346 348 def __getExpParameters(self):
347 349 if not(self.status):
348 350 return None
349 351
350 352 experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup')
351 353
352 354 expFinder = glob.glob1(experimentCfgPath,'*.exp')
353 355 if len(expFinder)== 0:
354 356 self.status = 0
355 357 return None
356 358
357 359 experimentFilename = os.path.join(experimentCfgPath,expFinder[0])
358 360
359 361 f = open(experimentFilename)
360 362 lines = f.readlines()
361 363 f.close()
362 364
363 365 parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*']
364 366 filterList = [fnmatch.filter(lines, x) for x in parmsList]
365 367
366 368
367 369 values = [re.sub(r'\D',"",x[0]) for x in filterList]
368 370
369 371 self.npulsesint_fromfile = int(values[0])
370 372 self.recordsperfile_fromfile = int(values[1])
371 373 self.nbeamcodes_fromfile = int(values[2])
372 374 self.ngates_fromfile = int(values[3])
373 375
374 376 tufileFinder = fnmatch.filter(lines, 'tufile=*')
375 377 tufile = tufileFinder[0].split('=')[1].split('\n')[0]
376 378 tufile = tufile.split('\r')[0]
377 379 tufilename = os.path.join(experimentCfgPath,tufile)
378 380
379 381 f = open(tufilename)
380 382 lines = f.readlines()
381 383 f.close()
382 384 self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6
383 385
384 386
385 387 self.status = 1
386 388
387 389 def __setIdsAndArrays(self):
388 390 self.dataByFrame = self.__setDataByFrame()
389 391 self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[0, :]
390 392 self.readRanges()
391 393 self.index_amisr_sample, self.index_amisr_buffer = self.radacHeaderObj.getIndexRangeToPulse(0)
392 394 self.radacTimeByFrame = numpy.zeros(self.radacHeaderObj.npulses)
393 395 self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame)
394 396
395 397
396 398 def __setNextFile(self):
397 399
398 400 newFile = self.__setNextFileOffline()
399 401
400 402 if not(newFile):
401 403 return 0
402 404
403 405 self.__readHeader()
404 406
405 407 if self.__firstFile:
406 408 self.__setIdsAndArrays()
407 409 self.__firstFile = False
408 410
409 411 self.__getBeamCode()
410 412 self.readDataBlock()
411 413
412 414
413 415 def setup(self,path=None,
414 416 startDate=None,
415 417 endDate=None,
416 418 startTime=datetime.time(0,0,0),
417 419 endTime=datetime.time(23,59,59),
418 420 walk=True,
419 421 timezone='ut',
420 422 all=0,):
421 423
422 424 self.timezone = timezone
423 425 self.all = all
424 426 #Busqueda de archivos offline
425 427 self.__searchFilesOffline(path, startDate, endDate, startTime, endTime, walk)
426 428
427 429 if not(self.filenameList):
428 430 print "There is no files into the folder: %s"%(path)
429 431
430 432 sys.exit(-1)
431 433
432 434 self.__getExpParameters()
433 435
434 436 self.fileIndex = -1
435 437
436 438 self.__setNextFile()
437 439
438 first_beamcode = self.radacHeaderObj.beamCodeByPulse[0,0]
439 index = numpy.where(self.radacHeaderObj.beamCodeByPulse[0,:]!=first_beamcode)[0][0]
440 self.profileIndex_offset = self.radacHeaderObj.pulseCount[0,:][index]
440 # first_beamcode = self.radacHeaderObj.beamCodeByPulse[0,0]
441 # index = numpy.where(self.radacHeaderObj.beamCodeByPulse[0,:]!=first_beamcode)[0][0]
442 self.profileIndex_offset = self.radacHeaderObj.pulseCount[0,:][0]
441 443 self.profileIndex = self.profileIndex_offset
442 444
443 445 def readRanges(self):
444 446 dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range')
445 #self.rangeFromFile = dataset.value
447
446 448 self.rangeFromFile = numpy.reshape(dataset.value,(-1))
447 return range
449 return self.rangeFromFile
448 450
449 451
450 452 def readRadacTime(self,idrecord, range1, range2):
451 453 self.radacTimeFromFile = self.radacHeaderObj.radacTime.value
452 454
453 455 radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
454 456 #radacTimeByFrame = dataset[idrecord - 1,range1]
455 457 #radacTimeByFrame = dataset[idrecord,range2]
456 458
457 459 return radacTimeByFrame
458 460
459 461 def readBeamCode(self, idrecord, range1, range2):
460 462 dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode')
461 463 beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
462 464 self.beamCodesFromFile = dataset.value
463 465
464 466 #beamcodeByFrame[range1] = dataset[idrecord - 1, range1]
465 467 #beamcodeByFrame[range2] = dataset[idrecord, range2]
466 468 beamcodeByFrame[range1] = dataset[idrecord, range1]
467 469 beamcodeByFrame[range2] = dataset[idrecord, range2]
468 470
469 471 return beamcodeByFrame
470 472
471 473
472 474 def __setDataByFrame(self):
473 475 ndata = 2 # porque es complejo
474 476 dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata))
475 477 return dataByFrame
476 478
477 479 def __readDataSet(self):
478 480 dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data')
479 481 return dataset
480 482
481 483 def __setDataBlock(self,):
482 484 real = self.dataByFrame[:,:,0] #asumo que 0 es real
483 485 imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario
484 486 datablock = real + imag*1j #armo el complejo
485 487 return datablock
486 488
487 489 def readSamples_version1(self,idrecord):
488 490 #estas tres primeras lineas solo se deben ejecutar una vez
489 491 if self.flagIsNewFile:
490 492 #reading dataset
491 493 self.dataset = self.__readDataSet()
492 494 self.flagIsNewFile = 0
493 495
494 496 if idrecord == 0:
495 497 self.dataByFrame[self.index4_schain_datablock, : ,:] = self.dataset[0, self.index_amisr_sample,:,:]
496 498 self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[0, self.index_amisr_sample]
497 499 datablock = self.__setDataBlock()
498 500
499 501 self.buffer = self.dataset[0, self.index_amisr_buffer,:,:]
500 502 self.buffer_radactime = self.radacHeaderObj.radacTime[0, self.index_amisr_buffer]
501 503
502 504 return datablock
503 505
504 506 self.dataByFrame[self.index4_buffer,:,:] = self.buffer.copy()
505 507 self.radacTimeByFrame[self.index4_buffer] = self.buffer_radactime.copy()
506 508 self.dataByFrame[self.index4_schain_datablock,:,:] = self.dataset[idrecord, self.index_amisr_sample,:,:]
507 509 self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_sample]
508 510 datablock = self.__setDataBlock()
509 511
510 512 self.buffer = self.dataset[idrecord, self.index_amisr_buffer, :, :]
511 513 self.buffer_radactime = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_buffer]
512 514
513 515 return datablock
514 516
515 517
516 518 def readSamples(self,idrecord):
517 519 if self.flagIsNewFile:
518 520 self.dataByFrame = self.__setDataByFrame()
519 521 self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :]
520 522
521 523 #reading ranges
522 524 self.readRanges()
523 525 #reading dataset
524 526 self.dataset = self.__readDataSet()
525 527
526 528 self.flagIsNewFile = 0
527 529 self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :]
528 530 self.dataByFrame = self.dataset[idrecord, :, :, :]
529 531 datablock = self.__setDataBlock()
530 532 return datablock
531 533
532 534
533 535 def readDataBlock(self):
534 536
535 537 self.datablock = self.readSamples_version1(self.idrecord_count)
536 538 #self.datablock = self.readSamples(self.idrecord_count)
537 539 #print 'record:', self.idrecord_count
538 540
539 541 self.idrecord_count += 1
540 542 self.profileIndex = 0
541 543
542 544 if self.idrecord_count >= self.radacHeaderObj.nrecords:
543 545 self.idrecord_count = 0
544 546 self.flagIsNewFile = 1
545 547
546 548 def readNextBlock(self):
547 549
548 550 self.readDataBlock()
549 551
550 552 if self.flagIsNewFile:
551 553 self.__setNextFile()
552 554 pass
553 555
554 556 def __hasNotDataInBuffer(self):
555 557 #self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record
556 558 if self.profileIndex >= self.radacHeaderObj.npulses:
557 559 return 1
558 560 return 0
559 561
560 562 def printUTC(self):
561 563 print self.dataOut.utctime
562 564 print ''
563 565
564 566 def setObjProperties(self):
565 567 self.dataOut.heightList = self.rangeFromFile/1000.0 #km
566 568 self.dataOut.nProfiles = self.radacHeaderObj.npulses
567 569 self.dataOut.nRecords = self.radacHeaderObj.nrecords
568 570 self.dataOut.nBeams = self.radacHeaderObj.nbeams
569 571 self.dataOut.ippSeconds = self.ippSeconds_fromfile
570 572 self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
571 573 self.dataOut.frequency = self.frequency_h5file
572 574 self.dataOut.npulseByFrame = self.npulseByFrame
573 575 self.dataOut.nBaud = None
574 576 self.dataOut.nCode = None
575 577 self.dataOut.code = None
576 578
577 579 self.dataOut.beamCodeDict = self.beamCodeDict
578 580 self.dataOut.beamRangeDict = self.beamRangeDict
579 581
580 582 if self.timezone == 'lt':
581 583 self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes
582 584 else:
583 585 self.dataOut.timeZone = 0 #by default time is UTC
584 586
585 587 def getData(self):
586 588
587 589 if self.flagNoMoreFiles:
588 590 self.dataOut.flagNoData = True
589 591 print 'Process finished'
590 592 return 0
591 593
592 594 if self.__hasNotDataInBuffer():
593 595 self.readNextBlock()
594 596
595 597
596 598 if self.datablock == None: # setear esta condicion cuando no hayan datos por leers
597 599 self.dataOut.flagNoData = True
598 600 return 0
599 601
600 602 self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1))
601 603
602 604 self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex]
603 605 self.dataOut.profileIndex = self.profileIndex
604 606 self.dataOut.flagNoData = False
605 607
606 608 self.profileIndex += 1
607 609
608 610 return self.dataOut.data
609 611
610 612
611 613 def run(self, **kwargs):
612 614 if not(self.isConfig):
613 615 self.setup(**kwargs)
614 616 self.setObjProperties()
615 617 self.isConfig = True
616 618
617 619 self.getData()
Show file before | Show file after | Hide comments
@@ -1,130 +1,136
1 1 '''
2 2 @author: Daniel Suarez
3 3 '''
4 4 import numpy
5 5 from jroproc_base import ProcessingUnit, Operation
6 6 from model.data.jroamisr import AMISR
7 7
8 8 class AMISRProc(ProcessingUnit):
9 9 def __init__(self):
10 10 ProcessingUnit.__init__(self)
11 11 self.objectDict = {}
12 12 self.dataOut = AMISR()
13 13
14 14 def run(self):
15 15 if self.dataIn.type == 'AMISR':
16 16 self.dataOut.copy(self.dataIn)
17 17
18 18
19 19 class PrintInfo(Operation):
20 20 def __init__(self):
21 21 self.__isPrinted = False
22 22
23 23 def run(self, dataOut):
24 24
25 25 if not self.__isPrinted:
26 26 print 'Number of Records by File: %d'%dataOut.nRecords
27 27 print 'Number of Pulses: %d'%dataOut.nProfiles
28 28 print 'Number of Pulses by Frame: %d'%dataOut.npulseByFrame
29 29 print 'Number of Samples by Pulse: %d'%len(dataOut.heightList)
30 30 print 'Ipp Seconds: %f'%dataOut.ippSeconds
31 31 print 'Number of Beams: %d'%dataOut.nBeams
32 32 print 'BeamCodes:'
33 33 beamStrList = ['Beam %d -> Code=%d, azimuth=%2.2f, zenith=%2.2f, gain=%2.2f'%(k,v[0],v[1],v[2],v[3]) for k,v in dataOut.beamCodeDict.items()]
34 34 for b in beamStrList:
35 35 print b
36 36 self.__isPrinted = True
37 37
38 38 return
39 39
40 40
41 41 class BeamSelector(Operation):
42 42 profileIndex = None
43 43 nProfiles = None
44 44
45 45 def __init__(self):
46 46
47 47 self.profileIndex = 0
48 self.__isConfig = False
48 49
49 50 def incIndex(self):
50 51 self.profileIndex += 1
51 52
52 53 if self.profileIndex >= self.nProfiles:
53 54 self.profileIndex = 0
54 55
55 56 def isProfileInRange(self, minIndex, maxIndex):
56 57
57 58 if self.profileIndex < minIndex:
58 59 return False
59 60
60 61 if self.profileIndex > maxIndex:
61 62 return False
62 63
63 64 return True
64 65
65 66 def isProfileInList(self, profileList):
66 67
67 68 if self.profileIndex not in profileList:
68 69 return False
69 70
70 71 return True
71 72
72 73 def run(self, dataOut, beam=None):
73 74
74 75 dataOut.flagNoData = True
76
77 if not(self.__isConfig):
78
75 79 self.nProfiles = dataOut.nProfiles
80 self.profileIndex = dataOut.profileIndex
81 self.__isConfig = True
76 82
77 83 if beam != None:
78 84 if self.isProfileInList(dataOut.beamRangeDict[beam]):
79 85 beamInfo = dataOut.beamCodeDict[beam]
80 86 dataOut.azimuth = beamInfo[1]
81 87 dataOut.zenith = beamInfo[2]
82 88 dataOut.gain = beamInfo[3]
83 89 dataOut.flagNoData = False
84 90
85 91 self.incIndex()
86 92 return 1
87 93
88 94 else:
89 95 raise ValueError, "BeamSelector needs beam value"
90 96
91 97 return 0
92 98
93 99 class ProfileToChannels(Operation):
94 100
95 101 def __init__(self):
96 102 self.__isConfig = False
97 103 self.__counter_chan = 0
98 104 self.buffer = None
99 105
100 106
101 107 def run(self, dataOut):
102 108
103 109 dataOut.flagNoData = True
104 110
105 111 if not(self.__isConfig):
106 112 nchannels = len(dataOut.beamRangeDict.keys())
107 113 nsamples = dataOut.nHeights
108 114 self.buffer = numpy.zeros((nchannels, nsamples), dtype = 'complex128')
109 115 self.__isConfig = True
110 116
111 117 for i in range(self.buffer.shape[0]):
112 118 if dataOut.profileIndex in dataOut.beamRangeDict[i]:
113 119 self.buffer[i,:] = dataOut.data
114 120 if len(dataOut.beam.codeList) < self.buffer.shape[0]:
115 121 beamInfo = dataOut.beamCodeDict[i]
116 122 dataOut.beam.codeList.append(beamInfo[0])
117 123 dataOut.beam.azimuthList.append(beamInfo[1])
118 124 dataOut.beam.zenithList.append(beamInfo[2])
119 125 break
120 126
121 127 self.__counter_chan += 1
122 128
123 129 if self.__counter_chan >= self.buffer.shape[0]:
124 130 self.__counter_chan = 0
125 131 dataOut.data = self.buffer.copy()
126 132 dataOut.channelList = range(self.buffer.shape[0])
127 133 self.__isConfig = False
128 134 dataOut.flagNoData = False
129 135 pass
130 136 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now