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