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