##// END OF EJS Templates
schain
RSS
receiving as unit reader
José Chávez -
r961:80664bd78a14
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,1
1 You should install "digital_rf_hdf5" module if you want to read USRP data
Show file before | Show file after | Hide comments
@@ -1,1 +1,1
1 <Project description="A schain project" id="191" name="project"><ReadUnit datatype="Voltage" id="1911" inputId="0" name="VoltageReader"><Operation id="19111" name="run" priority="1" type="self"><Parameter format="str" id="191111" name="datatype" value="VoltageReader" /><Parameter format="str" id="191112" name="path" value="/home/nanosat/schain" /><Parameter format="date" id="191113" name="startDate" value="1970/01/01" /><Parameter format="date" id="191114" name="endDate" value="2017/12/31" /><Parameter format="time" id="191115" name="startTime" value="00:00:00" /><Parameter format="time" id="191116" name="endTime" value="23:59:59" /><Parameter format="int" id="191118" name="walk" value="1" /><Parameter format="int" id="191119" name="verbose" value="1" /><Parameter format="int" id="191120" name="online" value="0" /></Operation></ReadUnit><ProcUnit datatype="Voltage" id="1912" inputId="1911" name="VoltageProc"><Operation id="19121" name="run" priority="1" type="self" /><Operation id="19122" name="ProfileSelector" priority="2" type="other"><Parameter format="intlist" id="191221" name="profileRangeList" value="120,183" /></Operation><Operation id="19123" name="RTIPlot" priority="3" type="plotter"><Parameter format="str" id="191231" name="wintitle" value="Jicamarca Radio Observatory" /><Parameter format="int" id="191232" name="showprofile" value="0" /><Parameter format="int" id="191233" name="xmin" value="0" /><Parameter format="int" id="191234" name="xmax" value="24" /><Parameter format="str" id="191235" name="figpath" value="/home/nanosat/schain/figs" /><Parameter format="int" id="191236" name="wr_period" value="5" /><Parameter format="int" id="191237" name="exp_code" value="22" /></Operation></ProcUnit></Project> No newline at end of file
1 <Project description="A schain project" id="191" name="project"><ReadUnit datatype="VoltageReader" id="1911" inputId="0" name="VoltageReader"><Operation id="19111" name="run" priority="1" type="self"><Parameter format="str" id="191111" name="datatype" value="VoltageReader" /><Parameter format="str" id="191112" name="path" value="/home/nanosat/schain" /><Parameter format="date" id="191113" name="startDate" value="1970/01/01" /><Parameter format="date" id="191114" name="endDate" value="2017/12/31" /><Parameter format="time" id="191115" name="startTime" value="00:00:00" /><Parameter format="time" id="191116" name="endTime" value="23:59:59" /><Parameter format="int" id="191118" name="walk" value="1" /><Parameter format="int" id="191119" name="verbose" value="1" /><Parameter format="int" id="191120" name="online" value="0" /></Operation></ReadUnit><ProcUnit datatype="VoltageProc" id="1912" inputId="1911" name="VoltageProc"><Operation id="19121" name="run" priority="1" type="self" /><Operation id="19122" name="ProfileSelector" priority="2" type="other"><Parameter format="intlist" id="191221" name="profileRangeList" value="120,183" /></Operation><Operation id="19123" name="RTIPlot" priority="3" type="other"><Parameter format="str" id="191231" name="wintitle" value="Jicamarca Radio Observatory" /><Parameter format="int" id="191232" name="showprofile" value="0" /><Parameter format="int" id="191233" name="xmin" value="0" /><Parameter format="int" id="191234" name="xmax" value="24" /><Parameter format="str" id="191235" name="figpath" value="/home/nanosat/schain/figs" /><Parameter format="int" id="191236" name="wr_period" value="5" /><Parameter format="int" id="191237" name="exp_code" value="22" /></Operation></ProcUnit></Project> No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1794 +1,1810
1 '''
1 '''
2 Created on Jul 2, 2014
2 Created on Jul 2, 2014
3
3
4 @author: roj-idl71
4 @author: roj-idl71
5 '''
5 '''
6 import os
6 import os
7 import sys
7 import sys
8 import glob
8 import glob
9 import time
9 import time
10 import numpy
10 import numpy
11 import fnmatch
11 import fnmatch
12 import inspect
12 import inspect
13 import time, datetime
13 import time, datetime
14 #import h5py
15 import traceback
14 import traceback
16
15
17 try:
16 try:
18 from gevent import sleep
17 from gevent import sleep
19 except:
18 except:
20 from time import sleep
19 from time import sleep
21
20
22 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
21 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
23 from schainpy.model.data.jroheaderIO import get_dtype_index, get_numpy_dtype, get_procflag_dtype, get_dtype_width
22 from schainpy.model.data.jroheaderIO import get_dtype_index, get_numpy_dtype, get_procflag_dtype, get_dtype_width
24
23
25 LOCALTIME = True
24 LOCALTIME = True
26
25
27 def isNumber(cad):
26 def isNumber(cad):
28 """
27 """
29 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
28 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
30
29
31 Excepciones:
30 Excepciones:
32 Si un determinado string no puede ser convertido a numero
31 Si un determinado string no puede ser convertido a numero
33 Input:
32 Input:
34 str, string al cual se le analiza para determinar si convertible a un numero o no
33 str, string al cual se le analiza para determinar si convertible a un numero o no
35
34
36 Return:
35 Return:
37 True : si el string es uno numerico
36 True : si el string es uno numerico
38 False : no es un string numerico
37 False : no es un string numerico
39 """
38 """
40 try:
39 try:
41 float( cad )
40 float( cad )
42 return True
41 return True
43 except:
42 except:
44 return False
43 return False
45
44
46 def isFileInEpoch(filename, startUTSeconds, endUTSeconds):
45 def isFileInEpoch(filename, startUTSeconds, endUTSeconds):
47 """
46 """
48 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
47 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
49
48
50 Inputs:
49 Inputs:
51 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
50 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
52
51
53 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
52 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
54 segundos contados desde 01/01/1970.
53 segundos contados desde 01/01/1970.
55 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
54 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
56 segundos contados desde 01/01/1970.
55 segundos contados desde 01/01/1970.
57
56
58 Return:
57 Return:
59 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
58 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
60 fecha especificado, de lo contrario retorna False.
59 fecha especificado, de lo contrario retorna False.
61
60
62 Excepciones:
61 Excepciones:
63 Si el archivo no existe o no puede ser abierto
62 Si el archivo no existe o no puede ser abierto
64 Si la cabecera no puede ser leida.
63 Si la cabecera no puede ser leida.
65
64
66 """
65 """
67 basicHeaderObj = BasicHeader(LOCALTIME)
66 basicHeaderObj = BasicHeader(LOCALTIME)
68
67
69 try:
68 try:
70 fp = open(filename,'rb')
69 fp = open(filename,'rb')
71 except IOError:
70 except IOError:
72 print "The file %s can't be opened" %(filename)
71 print "The file %s can't be opened" %(filename)
73 return 0
72 return 0
74
73
75 sts = basicHeaderObj.read(fp)
74 sts = basicHeaderObj.read(fp)
76 fp.close()
75 fp.close()
77
76
78 if not(sts):
77 if not(sts):
79 print "Skipping the file %s because it has not a valid header" %(filename)
78 print "Skipping the file %s because it has not a valid header" %(filename)
80 return 0
79 return 0
81
80
82 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
81 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
83 return 0
82 return 0
84
83
85 return 1
84 return 1
86
85
87 def isTimeInRange(thisTime, startTime, endTime):
86 def isTimeInRange(thisTime, startTime, endTime):
88
87
89 if endTime >= startTime:
88 if endTime >= startTime:
90 if (thisTime < startTime) or (thisTime > endTime):
89 if (thisTime < startTime) or (thisTime > endTime):
91 return 0
90 return 0
92
91
93 return 1
92 return 1
94 else:
93 else:
95 if (thisTime < startTime) and (thisTime > endTime):
94 if (thisTime < startTime) and (thisTime > endTime):
96 return 0
95 return 0
97
96
98 return 1
97 return 1
99
98
100 def isFileInTimeRange(filename, startDate, endDate, startTime, endTime):
99 def isFileInTimeRange(filename, startDate, endDate, startTime, endTime):
101 """
100 """
102 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
101 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
103
102
104 Inputs:
103 Inputs:
105 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
104 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
106
105
107 startDate : fecha inicial del rango seleccionado en formato datetime.date
106 startDate : fecha inicial del rango seleccionado en formato datetime.date
108
107
109 endDate : fecha final del rango seleccionado en formato datetime.date
108 endDate : fecha final del rango seleccionado en formato datetime.date
110
109
111 startTime : tiempo inicial del rango seleccionado en formato datetime.time
110 startTime : tiempo inicial del rango seleccionado en formato datetime.time
112
111
113 endTime : tiempo final del rango seleccionado en formato datetime.time
112 endTime : tiempo final del rango seleccionado en formato datetime.time
114
113
115 Return:
114 Return:
116 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
115 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
117 fecha especificado, de lo contrario retorna False.
116 fecha especificado, de lo contrario retorna False.
118
117
119 Excepciones:
118 Excepciones:
120 Si el archivo no existe o no puede ser abierto
119 Si el archivo no existe o no puede ser abierto
121 Si la cabecera no puede ser leida.
120 Si la cabecera no puede ser leida.
122
121
123 """
122 """
124
123
125
124
126 try:
125 try:
127 fp = open(filename,'rb')
126 fp = open(filename,'rb')
128 except IOError:
127 except IOError:
129 print "The file %s can't be opened" %(filename)
128 print "The file %s can't be opened" %(filename)
130 return None
129 return None
131
130
132 firstBasicHeaderObj = BasicHeader(LOCALTIME)
131 firstBasicHeaderObj = BasicHeader(LOCALTIME)
133 systemHeaderObj = SystemHeader()
132 systemHeaderObj = SystemHeader()
134 radarControllerHeaderObj = RadarControllerHeader()
133 radarControllerHeaderObj = RadarControllerHeader()
135 processingHeaderObj = ProcessingHeader()
134 processingHeaderObj = ProcessingHeader()
136
135
137 lastBasicHeaderObj = BasicHeader(LOCALTIME)
136 lastBasicHeaderObj = BasicHeader(LOCALTIME)
138
137
139 sts = firstBasicHeaderObj.read(fp)
138 sts = firstBasicHeaderObj.read(fp)
140
139
141 if not(sts):
140 if not(sts):
142 print "[Reading] Skipping the file %s because it has not a valid header" %(filename)
141 print "[Reading] Skipping the file %s because it has not a valid header" %(filename)
143 return None
142 return None
144
143
145 if not systemHeaderObj.read(fp):
144 if not systemHeaderObj.read(fp):
146 return None
145 return None
147
146
148 if not radarControllerHeaderObj.read(fp):
147 if not radarControllerHeaderObj.read(fp):
149 return None
148 return None
150
149
151 if not processingHeaderObj.read(fp):
150 if not processingHeaderObj.read(fp):
152 return None
151 return None
153
152
154 filesize = os.path.getsize(filename)
153 filesize = os.path.getsize(filename)
155
154
156 offset = processingHeaderObj.blockSize + 24 #header size
155 offset = processingHeaderObj.blockSize + 24 #header size
157
156
158 if filesize <= offset:
157 if filesize <= offset:
159 print "[Reading] %s: This file has not enough data" %filename
158 print "[Reading] %s: This file has not enough data" %filename
160 return None
159 return None
161
160
162 fp.seek(-offset, 2)
161 fp.seek(-offset, 2)
163
162
164 sts = lastBasicHeaderObj.read(fp)
163 sts = lastBasicHeaderObj.read(fp)
165
164
166 fp.close()
165 fp.close()
167
166
168 thisDatetime = lastBasicHeaderObj.datatime
167 thisDatetime = lastBasicHeaderObj.datatime
169 thisTime_last_block = thisDatetime.time()
168 thisTime_last_block = thisDatetime.time()
170
169
171 thisDatetime = firstBasicHeaderObj.datatime
170 thisDatetime = firstBasicHeaderObj.datatime
172 thisDate = thisDatetime.date()
171 thisDate = thisDatetime.date()
173 thisTime_first_block = thisDatetime.time()
172 thisTime_first_block = thisDatetime.time()
174
173
175 #General case
174 #General case
176 # o>>>>>>>>>>>>>><<<<<<<<<<<<<<o
175 # o>>>>>>>>>>>>>><<<<<<<<<<<<<<o
177 #-----------o----------------------------o-----------
176 #-----------o----------------------------o-----------
178 # startTime endTime
177 # startTime endTime
179
178
180 if endTime >= startTime:
179 if endTime >= startTime:
181 if (thisTime_last_block < startTime) or (thisTime_first_block > endTime):
180 if (thisTime_last_block < startTime) or (thisTime_first_block > endTime):
182 return None
181 return None
183
182
184 return thisDatetime
183 return thisDatetime
185
184
186 #If endTime < startTime then endTime belongs to the next day
185 #If endTime < startTime then endTime belongs to the next day
187
186
188
187
189 #<<<<<<<<<<<o o>>>>>>>>>>>
188 #<<<<<<<<<<<o o>>>>>>>>>>>
190 #-----------o----------------------------o-----------
189 #-----------o----------------------------o-----------
191 # endTime startTime
190 # endTime startTime
192
191
193 if (thisDate == startDate) and (thisTime_last_block < startTime):
192 if (thisDate == startDate) and (thisTime_last_block < startTime):
194 return None
193 return None
195
194
196 if (thisDate == endDate) and (thisTime_first_block > endTime):
195 if (thisDate == endDate) and (thisTime_first_block > endTime):
197 return None
196 return None
198
197
199 if (thisTime_last_block < startTime) and (thisTime_first_block > endTime):
198 if (thisTime_last_block < startTime) and (thisTime_first_block > endTime):
200 return None
199 return None
201
200
202 return thisDatetime
201 return thisDatetime
203
202
204 def isFolderInDateRange(folder, startDate=None, endDate=None):
203 def isFolderInDateRange(folder, startDate=None, endDate=None):
205 """
204 """
206 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
205 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
207
206
208 Inputs:
207 Inputs:
209 folder : nombre completo del directorio.
208 folder : nombre completo del directorio.
210 Su formato deberia ser "/path_root/?YYYYDDD"
209 Su formato deberia ser "/path_root/?YYYYDDD"
211
210
212 siendo:
211 siendo:
213 YYYY : Anio (ejemplo 2015)
212 YYYY : Anio (ejemplo 2015)
214 DDD : Dia del anio (ejemplo 305)
213 DDD : Dia del anio (ejemplo 305)
215
214
216 startDate : fecha inicial del rango seleccionado en formato datetime.date
215 startDate : fecha inicial del rango seleccionado en formato datetime.date
217
216
218 endDate : fecha final del rango seleccionado en formato datetime.date
217 endDate : fecha final del rango seleccionado en formato datetime.date
219
218
220 Return:
219 Return:
221 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
220 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
222 fecha especificado, de lo contrario retorna False.
221 fecha especificado, de lo contrario retorna False.
223 Excepciones:
222 Excepciones:
224 Si el directorio no tiene el formato adecuado
223 Si el directorio no tiene el formato adecuado
225 """
224 """
226
225
227 basename = os.path.basename(folder)
226 basename = os.path.basename(folder)
228
227
229 if not isRadarFolder(basename):
228 if not isRadarFolder(basename):
230 print "The folder %s has not the rigth format" %folder
229 print "The folder %s has not the rigth format" %folder
231 return 0
230 return 0
232
231
233 if startDate and endDate:
232 if startDate and endDate:
234 thisDate = getDateFromRadarFolder(basename)
233 thisDate = getDateFromRadarFolder(basename)
235
234
236 if thisDate < startDate:
235 if thisDate < startDate:
237 return 0
236 return 0
238
237
239 if thisDate > endDate:
238 if thisDate > endDate:
240 return 0
239 return 0
241
240
242 return 1
241 return 1
243
242
244 def isFileInDateRange(filename, startDate=None, endDate=None):
243 def isFileInDateRange(filename, startDate=None, endDate=None):
245 """
244 """
246 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
245 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
247
246
248 Inputs:
247 Inputs:
249 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
248 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
250
249
251 Su formato deberia ser "?YYYYDDDsss"
250 Su formato deberia ser "?YYYYDDDsss"
252
251
253 siendo:
252 siendo:
254 YYYY : Anio (ejemplo 2015)
253 YYYY : Anio (ejemplo 2015)
255 DDD : Dia del anio (ejemplo 305)
254 DDD : Dia del anio (ejemplo 305)
256 sss : set
255 sss : set
257
256
258 startDate : fecha inicial del rango seleccionado en formato datetime.date
257 startDate : fecha inicial del rango seleccionado en formato datetime.date
259
258
260 endDate : fecha final del rango seleccionado en formato datetime.date
259 endDate : fecha final del rango seleccionado en formato datetime.date
261
260
262 Return:
261 Return:
263 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
262 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
264 fecha especificado, de lo contrario retorna False.
263 fecha especificado, de lo contrario retorna False.
265 Excepciones:
264 Excepciones:
266 Si el archivo no tiene el formato adecuado
265 Si el archivo no tiene el formato adecuado
267 """
266 """
268
267
269 basename = os.path.basename(filename)
268 basename = os.path.basename(filename)
270
269
271 if not isRadarFile(basename):
270 if not isRadarFile(basename):
272 print "The filename %s has not the rigth format" %filename
271 print "The filename %s has not the rigth format" %filename
273 return 0
272 return 0
274
273
275 if startDate and endDate:
274 if startDate and endDate:
276 thisDate = getDateFromRadarFile(basename)
275 thisDate = getDateFromRadarFile(basename)
277
276
278 if thisDate < startDate:
277 if thisDate < startDate:
279 return 0
278 return 0
280
279
281 if thisDate > endDate:
280 if thisDate > endDate:
282 return 0
281 return 0
283
282
284 return 1
283 return 1
285
284
286 def getFileFromSet(path, ext, set):
285 def getFileFromSet(path, ext, set):
287 validFilelist = []
286 validFilelist = []
288 fileList = os.listdir(path)
287 fileList = os.listdir(path)
289
288
290 # 0 1234 567 89A BCDE
289 # 0 1234 567 89A BCDE
291 # H YYYY DDD SSS .ext
290 # H YYYY DDD SSS .ext
292
291
293 for thisFile in fileList:
292 for thisFile in fileList:
294 try:
293 try:
295 year = int(thisFile[1:5])
294 year = int(thisFile[1:5])
296 doy = int(thisFile[5:8])
295 doy = int(thisFile[5:8])
297 except:
296 except:
298 continue
297 continue
299
298
300 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
299 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
301 continue
300 continue
302
301
303 validFilelist.append(thisFile)
302 validFilelist.append(thisFile)
304
303
305 myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
304 myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
306
305
307 if len(myfile)!= 0:
306 if len(myfile)!= 0:
308 return myfile[0]
307 return myfile[0]
309 else:
308 else:
310 filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower())
309 filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower())
311 print 'the filename %s does not exist'%filename
310 print 'the filename %s does not exist'%filename
312 print '...going to the last file: '
311 print '...going to the last file: '
313
312
314 if validFilelist:
313 if validFilelist:
315 validFilelist = sorted( validFilelist, key=str.lower )
314 validFilelist = sorted( validFilelist, key=str.lower )
316 return validFilelist[-1]
315 return validFilelist[-1]
317
316
318 return None
317 return None
319
318
320 def getlastFileFromPath(path, ext):
319 def getlastFileFromPath(path, ext):
321 """
320 """
322 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
321 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
323 al final de la depuracion devuelve el ultimo file de la lista que quedo.
322 al final de la depuracion devuelve el ultimo file de la lista que quedo.
324
323
325 Input:
324 Input:
326 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
325 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
327 ext : extension de los files contenidos en una carpeta
326 ext : extension de los files contenidos en una carpeta
328
327
329 Return:
328 Return:
330 El ultimo file de una determinada carpeta, no se considera el path.
329 El ultimo file de una determinada carpeta, no se considera el path.
331 """
330 """
332 validFilelist = []
331 validFilelist = []
333 fileList = os.listdir(path)
332 fileList = os.listdir(path)
334
333
335 # 0 1234 567 89A BCDE
334 # 0 1234 567 89A BCDE
336 # H YYYY DDD SSS .ext
335 # H YYYY DDD SSS .ext
337
336
338 for thisFile in fileList:
337 for thisFile in fileList:
339
338
340 year = thisFile[1:5]
339 year = thisFile[1:5]
341 if not isNumber(year):
340 if not isNumber(year):
342 continue
341 continue
343
342
344 doy = thisFile[5:8]
343 doy = thisFile[5:8]
345 if not isNumber(doy):
344 if not isNumber(doy):
346 continue
345 continue
347
346
348 year = int(year)
347 year = int(year)
349 doy = int(doy)
348 doy = int(doy)
350
349
351 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
350 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
352 continue
351 continue
353
352
354 validFilelist.append(thisFile)
353 validFilelist.append(thisFile)
355
354
356 if validFilelist:
355 if validFilelist:
357 validFilelist = sorted( validFilelist, key=str.lower )
356 validFilelist = sorted( validFilelist, key=str.lower )
358 return validFilelist[-1]
357 return validFilelist[-1]
359
358
360 return None
359 return None
361
360
362 def checkForRealPath(path, foldercounter, year, doy, set, ext):
361 def checkForRealPath(path, foldercounter, year, doy, set, ext):
363 """
362 """
364 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
363 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
365 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
364 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
366 el path exacto de un determinado file.
365 el path exacto de un determinado file.
367
366
368 Example :
367 Example :
369 nombre correcto del file es .../.../D2009307/P2009307367.ext
368 nombre correcto del file es .../.../D2009307/P2009307367.ext
370
369
371 Entonces la funcion prueba con las siguientes combinaciones
370 Entonces la funcion prueba con las siguientes combinaciones
372 .../.../y2009307367.ext
371 .../.../y2009307367.ext
373 .../.../Y2009307367.ext
372 .../.../Y2009307367.ext
374 .../.../x2009307/y2009307367.ext
373 .../.../x2009307/y2009307367.ext
375 .../.../x2009307/Y2009307367.ext
374 .../.../x2009307/Y2009307367.ext
376 .../.../X2009307/y2009307367.ext
375 .../.../X2009307/y2009307367.ext
377 .../.../X2009307/Y2009307367.ext
376 .../.../X2009307/Y2009307367.ext
378 siendo para este caso, la ultima combinacion de letras, identica al file buscado
377 siendo para este caso, la ultima combinacion de letras, identica al file buscado
379
378
380 Return:
379 Return:
381 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
380 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
382 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
381 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
383 para el filename
382 para el filename
384 """
383 """
385 fullfilename = None
384 fullfilename = None
386 find_flag = False
385 find_flag = False
387 filename = None
386 filename = None
388
387
389 prefixDirList = [None,'d','D']
388 prefixDirList = [None,'d','D']
390 if ext.lower() == ".r": #voltage
389 if ext.lower() == ".r": #voltage
391 prefixFileList = ['d','D']
390 prefixFileList = ['d','D']
392 elif ext.lower() == ".pdata": #spectra
391 elif ext.lower() == ".pdata": #spectra
393 prefixFileList = ['p','P']
392 prefixFileList = ['p','P']
394 else:
393 else:
395 return None, filename
394 return None, filename
396
395
397 #barrido por las combinaciones posibles
396 #barrido por las combinaciones posibles
398 for prefixDir in prefixDirList:
397 for prefixDir in prefixDirList:
399 thispath = path
398 thispath = path
400 if prefixDir != None:
399 if prefixDir != None:
401 #formo el nombre del directorio xYYYYDDD (x=d o x=D)
400 #formo el nombre del directorio xYYYYDDD (x=d o x=D)
402 if foldercounter == 0:
401 if foldercounter == 0:
403 thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
402 thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
404 else:
403 else:
405 thispath = os.path.join(path, "%s%04d%03d_%02d" % ( prefixDir, year, doy , foldercounter))
404 thispath = os.path.join(path, "%s%04d%03d_%02d" % ( prefixDir, year, doy , foldercounter))
406 for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"
405 for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"
407 filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
406 filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
408 fullfilename = os.path.join( thispath, filename ) #formo el path completo
407 fullfilename = os.path.join( thispath, filename ) #formo el path completo
409
408
410 if os.path.exists( fullfilename ): #verifico que exista
409 if os.path.exists( fullfilename ): #verifico que exista
411 find_flag = True
410 find_flag = True
412 break
411 break
413 if find_flag:
412 if find_flag:
414 break
413 break
415
414
416 if not(find_flag):
415 if not(find_flag):
417 return None, filename
416 return None, filename
418
417
419 return fullfilename, filename
418 return fullfilename, filename
420
419
421 def isRadarFolder(folder):
420 def isRadarFolder(folder):
422 try:
421 try:
423 year = int(folder[1:5])
422 year = int(folder[1:5])
424 doy = int(folder[5:8])
423 doy = int(folder[5:8])
425 except:
424 except:
426 return 0
425 return 0
427
426
428 return 1
427 return 1
429
428
430 def isRadarFile(file):
429 def isRadarFile(file):
431 try:
430 try:
432 year = int(file[1:5])
431 year = int(file[1:5])
433 doy = int(file[5:8])
432 doy = int(file[5:8])
434 set = int(file[8:11])
433 set = int(file[8:11])
435 except:
434 except:
436 return 0
435 return 0
437
436
438 return 1
437 return 1
439
438
440 def getDateFromRadarFile(file):
439 def getDateFromRadarFile(file):
441 try:
440 try:
442 year = int(file[1:5])
441 year = int(file[1:5])
443 doy = int(file[5:8])
442 doy = int(file[5:8])
444 set = int(file[8:11])
443 set = int(file[8:11])
445 except:
444 except:
446 return None
445 return None
447
446
448 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy-1)
447 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy-1)
449 return thisDate
448 return thisDate
450
449
451 def getDateFromRadarFolder(folder):
450 def getDateFromRadarFolder(folder):
452 try:
451 try:
453 year = int(folder[1:5])
452 year = int(folder[1:5])
454 doy = int(folder[5:8])
453 doy = int(folder[5:8])
455 except:
454 except:
456 return None
455 return None
457
456
458 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy-1)
457 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy-1)
459 return thisDate
458 return thisDate
460
459
461 class JRODataIO:
460 class JRODataIO:
462
461
463 c = 3E8
462 c = 3E8
464
463
465 isConfig = False
464 isConfig = False
466
465
467 basicHeaderObj = None
466 basicHeaderObj = None
468
467
469 systemHeaderObj = None
468 systemHeaderObj = None
470
469
471 radarControllerHeaderObj = None
470 radarControllerHeaderObj = None
472
471
473 processingHeaderObj = None
472 processingHeaderObj = None
474
473
475 dtype = None
474 dtype = None
476
475
477 pathList = []
476 pathList = []
478
477
479 filenameList = []
478 filenameList = []
480
479
481 filename = None
480 filename = None
482
481
483 ext = None
482 ext = None
484
483
485 flagIsNewFile = 1
484 flagIsNewFile = 1
486
485
487 flagDiscontinuousBlock = 0
486 flagDiscontinuousBlock = 0
488
487
489 flagIsNewBlock = 0
488 flagIsNewBlock = 0
490
489
491 fp = None
490 fp = None
492
491
493 firstHeaderSize = 0
492 firstHeaderSize = 0
494
493
495 basicHeaderSize = 24
494 basicHeaderSize = 24
496
495
497 versionFile = 1103
496 versionFile = 1103
498
497
499 fileSize = None
498 fileSize = None
500
499
501 # ippSeconds = None
500 # ippSeconds = None
502
501
503 fileSizeByHeader = None
502 fileSizeByHeader = None
504
503
505 fileIndex = None
504 fileIndex = None
506
505
507 profileIndex = None
506 profileIndex = None
508
507
509 blockIndex = None
508 blockIndex = None
510
509
511 nTotalBlocks = None
510 nTotalBlocks = None
512
511
513 maxTimeStep = 30
512 maxTimeStep = 30
514
513
515 lastUTTime = None
514 lastUTTime = None
516
515
517 datablock = None
516 datablock = None
518
517
519 dataOut = None
518 dataOut = None
520
519
521 blocksize = None
520 blocksize = None
522
521
523 getByBlock = False
522 getByBlock = False
524
523
525 def __init__(self):
524 def __init__(self):
526
525
527 raise NotImplementedError
526 raise NotImplementedError
528
527
529 def run(self):
528 def run(self):
530
529
531 raise NotImplementedError
530 raise NotImplementedError
532
531
533 def getDtypeWidth(self):
532 def getDtypeWidth(self):
534
533
535 dtype_index = get_dtype_index(self.dtype)
534 dtype_index = get_dtype_index(self.dtype)
536 dtype_width = get_dtype_width(dtype_index)
535 dtype_width = get_dtype_width(dtype_index)
537
536
538 return dtype_width
537 return dtype_width
539
538
540 def getAllowedArgs(self):
539 def getAllowedArgs(self):
541 return inspect.getargspec(self.run).args
540 return inspect.getargspec(self.run).args
542
541
543 class JRODataReader(JRODataIO):
542 class JRODataReader(JRODataIO):
544
543
545
544
546 online = 0
545 online = 0
547
546
548 realtime = 0
547 realtime = 0
549
548
550 nReadBlocks = 0
549 nReadBlocks = 0
551
550
552 delay = 10 #number of seconds waiting a new file
551 delay = 10 #number of seconds waiting a new file
553
552
554 nTries = 3 #quantity tries
553 nTries = 3 #quantity tries
555
554
556 nFiles = 3 #number of files for searching
555 nFiles = 3 #number of files for searching
557
556
558 path = None
557 path = None
559
558
560 foldercounter = 0
559 foldercounter = 0
561
560
562 flagNoMoreFiles = 0
561 flagNoMoreFiles = 0
563
562
564 datetimeList = []
563 datetimeList = []
565
564
566 __isFirstTimeOnline = 1
565 __isFirstTimeOnline = 1
567
566
568 __printInfo = True
567 __printInfo = True
569
568
570 profileIndex = None
569 profileIndex = None
571
570
572 nTxs = 1
571 nTxs = 1
573
572
574 txIndex = None
573 txIndex = None
575
574
576 #Added--------------------
575 #Added--------------------
577
576
578 selBlocksize = None
577 selBlocksize = None
579
578
580 selBlocktime = None
579 selBlocktime = None
581
580
582
581
583 def __init__(self):
582 def __init__(self):
584
583
585 """
584 """
586 This class is used to find data files
585 This class is used to find data files
587
586
588 Example:
587 Example:
589 reader = JRODataReader()
588 reader = JRODataReader()
590 fileList = reader.findDataFiles()
589 fileList = reader.findDataFiles()
591
590
592 """
591 """
593 pass
592 pass
594
593
595
594
596 def createObjByDefault(self):
595 def createObjByDefault(self):
597 """
596 """
598
597
599 """
598 """
600 raise NotImplementedError
599 raise NotImplementedError
601
600
602 def getBlockDimension(self):
601 def getBlockDimension(self):
603
602
604 raise NotImplementedError
603 raise NotImplementedError
605
604
606 def __searchFilesOffLine(self,
605 def __searchFilesOffLine(self,
607 path,
606 path,
608 startDate=None,
607 startDate=None,
609 endDate=None,
608 endDate=None,
610 startTime=datetime.time(0,0,0),
609 startTime=datetime.time(0,0,0),
611 endTime=datetime.time(23,59,59),
610 endTime=datetime.time(23,59,59),
612 set=None,
611 set=None,
613 expLabel='',
612 expLabel='',
614 ext='.r',
613 ext='.r',
615 queue=None,
614 queue=None,
616 cursor=None,
615 cursor=None,
617 skip=None,
616 skip=None,
618 walk=True):
617 walk=True):
619
618
620 self.filenameList = []
619 self.filenameList = []
621 self.datetimeList = []
620 self.datetimeList = []
622
621
623 pathList = []
622 pathList = []
624
623
625 dateList, pathList = self.findDatafiles(path, startDate, endDate, expLabel, ext, walk, include_path=True)
624 dateList, pathList = self.findDatafiles(path, startDate, endDate, expLabel, ext, walk, include_path=True)
626
625
627 if dateList == []:
626 if dateList == []:
628 # print "[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" %(startDate, endDate, ext, path)
627 # print "[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" %(startDate, endDate, ext, path)
629 return None, None
628 return None, None
630
629
631 if len(dateList) > 1:
630 if len(dateList) > 1:
632 print "[Reading] Data found for date range [%s - %s]: total days = %d" %(startDate, endDate, len(dateList))
631 print "[Reading] Data found for date range [%s - %s]: total days = %d" %(startDate, endDate, len(dateList))
633 else:
632 else:
634 print "[Reading] Data found for date range [%s - %s]: date = %s" %(startDate, endDate, dateList[0])
633 print "[Reading] Data found for date range [%s - %s]: date = %s" %(startDate, endDate, dateList[0])
635
634
636 filenameList = []
635 filenameList = []
637 datetimeList = []
636 datetimeList = []
638
637
639 for thisPath in pathList:
638 for thisPath in pathList:
640 # thisPath = pathList[pathDict[file]]
639 # thisPath = pathList[pathDict[file]]
641
640
642 fileList = glob.glob1(thisPath, "*%s" %ext)
641 fileList = glob.glob1(thisPath, "*%s" %ext)
643 fileList.sort()
642 fileList.sort()
644
643
645 skippedFileList = []
644 skippedFileList = []
646
645
647 if cursor is not None and skip is not None:
646 if cursor is not None and skip is not None:
648 # if cursor*skip > len(fileList):
647 # if cursor*skip > len(fileList):
649 if skip == 0:
648 if skip == 0:
650 if queue is not None:
649 if queue is not None:
651 queue.put(len(fileList))
650 queue.put(len(fileList))
652 skippedFileList = []
651 skippedFileList = []
653 else:
652 else:
654 skippedFileList = fileList[cursor*skip: cursor*skip + skip]
653 skippedFileList = fileList[cursor*skip: cursor*skip + skip]
655
654
656 else:
655 else:
657 skippedFileList = fileList
656 skippedFileList = fileList
658
657
659 for file in skippedFileList:
658 for file in skippedFileList:
660
659
661 filename = os.path.join(thisPath,file)
660 filename = os.path.join(thisPath,file)
662
661
663 if not isFileInDateRange(filename, startDate, endDate):
662 if not isFileInDateRange(filename, startDate, endDate):
664 continue
663 continue
665
664
666 thisDatetime = isFileInTimeRange(filename, startDate, endDate, startTime, endTime)
665 thisDatetime = isFileInTimeRange(filename, startDate, endDate, startTime, endTime)
667
666
668 if not(thisDatetime):
667 if not(thisDatetime):
669 continue
668 continue
670
669
671 filenameList.append(filename)
670 filenameList.append(filename)
672 datetimeList.append(thisDatetime)
671 datetimeList.append(thisDatetime)
673
672
674 if not(filenameList):
673 if not(filenameList):
675 print "[Reading] Time range selected invalid [%s - %s]: No *%s files in %s)" %(startTime, endTime, ext, path)
674 print "[Reading] Time range selected invalid [%s - %s]: No *%s files in %s)" %(startTime, endTime, ext, path)
676 return None, None
675 return None, None
677
676
678 print "[Reading] %d file(s) was(were) found in time range: %s - %s" %(len(filenameList), startTime, endTime)
677 print "[Reading] %d file(s) was(were) found in time range: %s - %s" %(len(filenameList), startTime, endTime)
679 print
678 print
680
679
681 for i in range(len(filenameList)):
680 for i in range(len(filenameList)):
682 print "[Reading] %s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
681 print "[Reading] %s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
683
682
684 self.filenameList = filenameList
683 self.filenameList = filenameList
685 self.datetimeList = datetimeList
684 self.datetimeList = datetimeList
686
685
687 return pathList, filenameList
686 return pathList, filenameList
688
687
689 def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True, set=None):
688 def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True, set=None):
690
689
691 """
690 """
692 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
691 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
693 devuelve el archivo encontrado ademas de otros datos.
692 devuelve el archivo encontrado ademas de otros datos.
694
693
695 Input:
694 Input:
696 path : carpeta donde estan contenidos los files que contiene data
695 path : carpeta donde estan contenidos los files que contiene data
697
696
698 expLabel : Nombre del subexperimento (subfolder)
697 expLabel : Nombre del subexperimento (subfolder)
699
698
700 ext : extension de los files
699 ext : extension de los files
701
700
702 walk : Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
701 walk : Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
703
702
704 Return:
703 Return:
705 directory : eL directorio donde esta el file encontrado
704 directory : eL directorio donde esta el file encontrado
706 filename : el ultimo file de una determinada carpeta
705 filename : el ultimo file de una determinada carpeta
707 year : el anho
706 year : el anho
708 doy : el numero de dia del anho
707 doy : el numero de dia del anho
709 set : el set del archivo
708 set : el set del archivo
710
709
711
710
712 """
711 """
713 if not os.path.isdir(path):
712 if not os.path.isdir(path):
714 return None, None, None, None, None, None
713 return None, None, None, None, None, None
715
714
716 dirList = []
715 dirList = []
717
716
718 if not walk:
717 if not walk:
719 fullpath = path
718 fullpath = path
720 foldercounter = 0
719 foldercounter = 0
721 else:
720 else:
722 #Filtra solo los directorios
721 #Filtra solo los directorios
723 for thisPath in os.listdir(path):
722 for thisPath in os.listdir(path):
724 if not os.path.isdir(os.path.join(path,thisPath)):
723 if not os.path.isdir(os.path.join(path,thisPath)):
725 continue
724 continue
726 if not isRadarFolder(thisPath):
725 if not isRadarFolder(thisPath):
727 continue
726 continue
728
727
729 dirList.append(thisPath)
728 dirList.append(thisPath)
730
729
731 if not(dirList):
730 if not(dirList):
732 return None, None, None, None, None, None
731 return None, None, None, None, None, None
733
732
734 dirList = sorted( dirList, key=str.lower )
733 dirList = sorted( dirList, key=str.lower )
735
734
736 doypath = dirList[-1]
735 doypath = dirList[-1]
737 foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0
736 foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0
738 fullpath = os.path.join(path, doypath, expLabel)
737 fullpath = os.path.join(path, doypath, expLabel)
739
738
740
739
741 print "[Reading] %s folder was found: " %(fullpath )
740 print "[Reading] %s folder was found: " %(fullpath )
742
741
743 if set == None:
742 if set == None:
744 filename = getlastFileFromPath(fullpath, ext)
743 filename = getlastFileFromPath(fullpath, ext)
745 else:
744 else:
746 filename = getFileFromSet(fullpath, ext, set)
745 filename = getFileFromSet(fullpath, ext, set)
747
746
748 if not(filename):
747 if not(filename):
749 return None, None, None, None, None, None
748 return None, None, None, None, None, None
750
749
751 print "[Reading] %s file was found" %(filename)
750 print "[Reading] %s file was found" %(filename)
752
751
753 if not(self.__verifyFile(os.path.join(fullpath, filename))):
752 if not(self.__verifyFile(os.path.join(fullpath, filename))):
754 return None, None, None, None, None, None
753 return None, None, None, None, None, None
755
754
756 year = int( filename[1:5] )
755 year = int( filename[1:5] )
757 doy = int( filename[5:8] )
756 doy = int( filename[5:8] )
758 set = int( filename[8:11] )
757 set = int( filename[8:11] )
759
758
760 return fullpath, foldercounter, filename, year, doy, set
759 return fullpath, foldercounter, filename, year, doy, set
761
760
762 def __setNextFileOffline(self):
761 def __setNextFileOffline(self):
763
762
764 idFile = self.fileIndex
763 idFile = self.fileIndex
765
764
766 while (True):
765 while (True):
767 idFile += 1
766 idFile += 1
768 if not(idFile < len(self.filenameList)):
767 if not(idFile < len(self.filenameList)):
769 self.flagNoMoreFiles = 1
768 self.flagNoMoreFiles = 1
770 # print "[Reading] No more Files"
769 # print "[Reading] No more Files"
771 return 0
770 return 0
772
771
773 filename = self.filenameList[idFile]
772 filename = self.filenameList[idFile]
774
773
775 if not(self.__verifyFile(filename)):
774 if not(self.__verifyFile(filename)):
776 continue
775 continue
777
776
778 fileSize = os.path.getsize(filename)
777 fileSize = os.path.getsize(filename)
779 fp = open(filename,'rb')
778 fp = open(filename,'rb')
780 break
779 break
781
780
782 self.flagIsNewFile = 1
781 self.flagIsNewFile = 1
783 self.fileIndex = idFile
782 self.fileIndex = idFile
784 self.filename = filename
783 self.filename = filename
785 self.fileSize = fileSize
784 self.fileSize = fileSize
786 self.fp = fp
785 self.fp = fp
787
786
788 # print "[Reading] Setting the file: %s"%self.filename
787 # print "[Reading] Setting the file: %s"%self.filename
789
788
790 return 1
789 return 1
791
790
792 def __setNextFileOnline(self):
791 def __setNextFileOnline(self):
793 """
792 """
794 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
793 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
795 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
794 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
796 siguientes.
795 siguientes.
797
796
798 Affected:
797 Affected:
799 self.flagIsNewFile
798 self.flagIsNewFile
800 self.filename
799 self.filename
801 self.fileSize
800 self.fileSize
802 self.fp
801 self.fp
803 self.set
802 self.set
804 self.flagNoMoreFiles
803 self.flagNoMoreFiles
805
804
806 Return:
805 Return:
807 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
806 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
808 1 : si el file fue abierto con exito y esta listo a ser leido
807 1 : si el file fue abierto con exito y esta listo a ser leido
809
808
810 Excepciones:
809 Excepciones:
811 Si un determinado file no puede ser abierto
810 Si un determinado file no puede ser abierto
812 """
811 """
813 nFiles = 0
812 nFiles = 0
814 fileOk_flag = False
813 fileOk_flag = False
815 firstTime_flag = True
814 firstTime_flag = True
816
815
817 self.set += 1
816 self.set += 1
818
817
819 if self.set > 999:
818 if self.set > 999:
820 self.set = 0
819 self.set = 0
821 self.foldercounter += 1
820 self.foldercounter += 1
822
821
823 #busca el 1er file disponible
822 #busca el 1er file disponible
824 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
823 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
825 if fullfilename:
824 if fullfilename:
826 if self.__verifyFile(fullfilename, False):
825 if self.__verifyFile(fullfilename, False):
827 fileOk_flag = True
826 fileOk_flag = True
828
827
829 #si no encuentra un file entonces espera y vuelve a buscar
828 #si no encuentra un file entonces espera y vuelve a buscar
830 if not(fileOk_flag):
829 if not(fileOk_flag):
831 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
830 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
832
831
833 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
832 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
834 tries = self.nTries
833 tries = self.nTries
835 else:
834 else:
836 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
835 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
837
836
838 for nTries in range( tries ):
837 for nTries in range( tries ):
839 if firstTime_flag:
838 if firstTime_flag:
840 print "\t[Reading] Waiting %0.2f sec for the next file: \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
839 print "\t[Reading] Waiting %0.2f sec for the next file: \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
841 sleep( self.delay )
840 sleep( self.delay )
842 else:
841 else:
843 print "\t[Reading] Searching the next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
842 print "\t[Reading] Searching the next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
844
843
845 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
844 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
846 if fullfilename:
845 if fullfilename:
847 if self.__verifyFile(fullfilename):
846 if self.__verifyFile(fullfilename):
848 fileOk_flag = True
847 fileOk_flag = True
849 break
848 break
850
849
851 if fileOk_flag:
850 if fileOk_flag:
852 break
851 break
853
852
854 firstTime_flag = False
853 firstTime_flag = False
855
854
856 print "\t[Reading] Skipping the file \"%s\" due to this file doesn't exist" % filename
855 print "\t[Reading] Skipping the file \"%s\" due to this file doesn't exist" % filename
857 self.set += 1
856 self.set += 1
858
857
859 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
858 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
860 self.set = 0
859 self.set = 0
861 self.doy += 1
860 self.doy += 1
862 self.foldercounter = 0
861 self.foldercounter = 0
863
862
864 if fileOk_flag:
863 if fileOk_flag:
865 self.fileSize = os.path.getsize( fullfilename )
864 self.fileSize = os.path.getsize( fullfilename )
866 self.filename = fullfilename
865 self.filename = fullfilename
867 self.flagIsNewFile = 1
866 self.flagIsNewFile = 1
868 if self.fp != None: self.fp.close()
867 if self.fp != None: self.fp.close()
869 self.fp = open(fullfilename, 'rb')
868 self.fp = open(fullfilename, 'rb')
870 self.flagNoMoreFiles = 0
869 self.flagNoMoreFiles = 0
871 # print '[Reading] Setting the file: %s' % fullfilename
870 # print '[Reading] Setting the file: %s' % fullfilename
872 else:
871 else:
873 self.fileSize = 0
872 self.fileSize = 0
874 self.filename = None
873 self.filename = None
875 self.flagIsNewFile = 0
874 self.flagIsNewFile = 0
876 self.fp = None
875 self.fp = None
877 self.flagNoMoreFiles = 1
876 self.flagNoMoreFiles = 1
878 # print '[Reading] No more files to read'
877 # print '[Reading] No more files to read'
879
878
880 return fileOk_flag
879 return fileOk_flag
881
880
882 def setNextFile(self):
881 def setNextFile(self):
883 if self.fp != None:
882 if self.fp != None:
884 self.fp.close()
883 self.fp.close()
885
884
886 if self.online:
885 if self.online:
887 newFile = self.__setNextFileOnline()
886 newFile = self.__setNextFileOnline()
888 else:
887 else:
889 newFile = self.__setNextFileOffline()
888 newFile = self.__setNextFileOffline()
890
889
891 if not(newFile):
890 if not(newFile):
892 print '[Reading] No more files to read'
891 print '[Reading] No more files to read'
893 return 0
892 return 0
894
893
895 if self.verbose:
894 if self.verbose:
896 print '[Reading] Setting the file: %s' % self.filename
895 print '[Reading] Setting the file: %s' % self.filename
897
896
898 self.__readFirstHeader()
897 self.__readFirstHeader()
899 self.nReadBlocks = 0
898 self.nReadBlocks = 0
900 return 1
899 return 1
901
900
902 def __waitNewBlock(self):
901 def __waitNewBlock(self):
903 """
902 """
904 Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
903 Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
905
904
906 Si el modo de lectura es OffLine siempre retorn 0
905 Si el modo de lectura es OffLine siempre retorn 0
907 """
906 """
908 if not self.online:
907 if not self.online:
909 return 0
908 return 0
910
909
911 if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
910 if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
912 return 0
911 return 0
913
912
914 currentPointer = self.fp.tell()
913 currentPointer = self.fp.tell()
915
914
916 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
915 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
917
916
918 for nTries in range( self.nTries ):
917 for nTries in range( self.nTries ):
919
918
920 self.fp.close()
919 self.fp.close()
921 self.fp = open( self.filename, 'rb' )
920 self.fp = open( self.filename, 'rb' )
922 self.fp.seek( currentPointer )
921 self.fp.seek( currentPointer )
923
922
924 self.fileSize = os.path.getsize( self.filename )
923 self.fileSize = os.path.getsize( self.filename )
925 currentSize = self.fileSize - currentPointer
924 currentSize = self.fileSize - currentPointer
926
925
927 if ( currentSize >= neededSize ):
926 if ( currentSize >= neededSize ):
928 self.basicHeaderObj.read(self.fp)
927 self.basicHeaderObj.read(self.fp)
929 return 1
928 return 1
930
929
931 if self.fileSize == self.fileSizeByHeader:
930 if self.fileSize == self.fileSizeByHeader:
932 # self.flagEoF = True
931 # self.flagEoF = True
933 return 0
932 return 0
934
933
935 print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
934 print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
936 sleep( self.delay )
935 sleep( self.delay )
937
936
938
937
939 return 0
938 return 0
940
939
941 def waitDataBlock(self,pointer_location):
940 def waitDataBlock(self,pointer_location):
942
941
943 currentPointer = pointer_location
942 currentPointer = pointer_location
944
943
945 neededSize = self.processingHeaderObj.blockSize #+ self.basicHeaderSize
944 neededSize = self.processingHeaderObj.blockSize #+ self.basicHeaderSize
946
945
947 for nTries in range( self.nTries ):
946 for nTries in range( self.nTries ):
948 self.fp.close()
947 self.fp.close()
949 self.fp = open( self.filename, 'rb' )
948 self.fp = open( self.filename, 'rb' )
950 self.fp.seek( currentPointer )
949 self.fp.seek( currentPointer )
951
950
952 self.fileSize = os.path.getsize( self.filename )
951 self.fileSize = os.path.getsize( self.filename )
953 currentSize = self.fileSize - currentPointer
952 currentSize = self.fileSize - currentPointer
954
953
955 if ( currentSize >= neededSize ):
954 if ( currentSize >= neededSize ):
956 return 1
955 return 1
957
956
958 print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
957 print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
959 sleep( self.delay )
958 sleep( self.delay )
960
959
961 return 0
960 return 0
962
961
963 def __jumpToLastBlock(self):
962 def __jumpToLastBlock(self):
964
963
965 if not(self.__isFirstTimeOnline):
964 if not(self.__isFirstTimeOnline):
966 return
965 return
967
966
968 csize = self.fileSize - self.fp.tell()
967 csize = self.fileSize - self.fp.tell()
969 blocksize = self.processingHeaderObj.blockSize
968 blocksize = self.processingHeaderObj.blockSize
970
969
971 #salta el primer bloque de datos
970 #salta el primer bloque de datos
972 if csize > self.processingHeaderObj.blockSize:
971 if csize > self.processingHeaderObj.blockSize:
973 self.fp.seek(self.fp.tell() + blocksize)
972 self.fp.seek(self.fp.tell() + blocksize)
974 else:
973 else:
975 return
974 return
976
975
977 csize = self.fileSize - self.fp.tell()
976 csize = self.fileSize - self.fp.tell()
978 neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
977 neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
979 while True:
978 while True:
980
979
981 if self.fp.tell()<self.fileSize:
980 if self.fp.tell()<self.fileSize:
982 self.fp.seek(self.fp.tell() + neededsize)
981 self.fp.seek(self.fp.tell() + neededsize)
983 else:
982 else:
984 self.fp.seek(self.fp.tell() - neededsize)
983 self.fp.seek(self.fp.tell() - neededsize)
985 break
984 break
986
985
987 # csize = self.fileSize - self.fp.tell()
986 # csize = self.fileSize - self.fp.tell()
988 # neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
987 # neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
989 # factor = int(csize/neededsize)
988 # factor = int(csize/neededsize)
990 # if factor > 0:
989 # if factor > 0:
991 # self.fp.seek(self.fp.tell() + factor*neededsize)
990 # self.fp.seek(self.fp.tell() + factor*neededsize)
992
991
993 self.flagIsNewFile = 0
992 self.flagIsNewFile = 0
994 self.__isFirstTimeOnline = 0
993 self.__isFirstTimeOnline = 0
995
994
996 def __setNewBlock(self):
995 def __setNewBlock(self):
997
996
998 if self.fp == None:
997 if self.fp == None:
999 return 0
998 return 0
1000
999
1001 # if self.online:
1000 # if self.online:
1002 # self.__jumpToLastBlock()
1001 # self.__jumpToLastBlock()
1003
1002
1004 if self.flagIsNewFile:
1003 if self.flagIsNewFile:
1005 self.lastUTTime = self.basicHeaderObj.utc
1004 self.lastUTTime = self.basicHeaderObj.utc
1006 return 1
1005 return 1
1007
1006
1008 if self.realtime:
1007 if self.realtime:
1009 self.flagDiscontinuousBlock = 1
1008 self.flagDiscontinuousBlock = 1
1010 if not(self.setNextFile()):
1009 if not(self.setNextFile()):
1011 return 0
1010 return 0
1012 else:
1011 else:
1013 return 1
1012 return 1
1014
1013
1015 currentSize = self.fileSize - self.fp.tell()
1014 currentSize = self.fileSize - self.fp.tell()
1016 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
1015 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
1017
1016
1018 if (currentSize >= neededSize):
1017 if (currentSize >= neededSize):
1019 self.basicHeaderObj.read(self.fp)
1018 self.basicHeaderObj.read(self.fp)
1020 self.lastUTTime = self.basicHeaderObj.utc
1019 self.lastUTTime = self.basicHeaderObj.utc
1021 return 1
1020 return 1
1022
1021
1023 if self.__waitNewBlock():
1022 if self.__waitNewBlock():
1024 self.lastUTTime = self.basicHeaderObj.utc
1023 self.lastUTTime = self.basicHeaderObj.utc
1025 return 1
1024 return 1
1026
1025
1027 if not(self.setNextFile()):
1026 if not(self.setNextFile()):
1028 return 0
1027 return 0
1029
1028
1030 deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
1029 deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
1031 self.lastUTTime = self.basicHeaderObj.utc
1030 self.lastUTTime = self.basicHeaderObj.utc
1032
1031
1033 self.flagDiscontinuousBlock = 0
1032 self.flagDiscontinuousBlock = 0
1034
1033
1035 if deltaTime > self.maxTimeStep:
1034 if deltaTime > self.maxTimeStep:
1036 self.flagDiscontinuousBlock = 1
1035 self.flagDiscontinuousBlock = 1
1037
1036
1038 return 1
1037 return 1
1039
1038
1040 def readNextBlock(self):
1039 def readNextBlock(self):
1041
1040
1042 #Skip block out of startTime and endTime
1041 #Skip block out of startTime and endTime
1043 while True:
1042 while True:
1044 if not(self.__setNewBlock()):
1043 if not(self.__setNewBlock()):
1045 return 0
1044 return 0
1046
1045
1047 if not(self.readBlock()):
1046 if not(self.readBlock()):
1048 return 0
1047 return 0
1049
1048
1050 self.getBasicHeader()
1049 self.getBasicHeader()
1051
1050
1052 if not isTimeInRange(self.dataOut.datatime.time(), self.startTime, self.endTime):
1051 if not isTimeInRange(self.dataOut.datatime.time(), self.startTime, self.endTime):
1053
1052
1054 print "[Reading] Block No. %d/%d -> %s [Skipping]" %(self.nReadBlocks,
1053 print "[Reading] Block No. %d/%d -> %s [Skipping]" %(self.nReadBlocks,
1055 self.processingHeaderObj.dataBlocksPerFile,
1054 self.processingHeaderObj.dataBlocksPerFile,
1056 self.dataOut.datatime.ctime())
1055 self.dataOut.datatime.ctime())
1057 continue
1056 continue
1058
1057
1059 break
1058 break
1060
1059
1061 if self.verbose:
1060 if self.verbose:
1062 print "[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
1061 print "[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
1063 self.processingHeaderObj.dataBlocksPerFile,
1062 self.processingHeaderObj.dataBlocksPerFile,
1064 self.dataOut.datatime.ctime())
1063 self.dataOut.datatime.ctime())
1065 return 1
1064 return 1
1066
1065
1067 def __readFirstHeader(self):
1066 def __readFirstHeader(self):
1068
1067
1069 self.basicHeaderObj.read(self.fp)
1068 self.basicHeaderObj.read(self.fp)
1070 self.systemHeaderObj.read(self.fp)
1069 self.systemHeaderObj.read(self.fp)
1071 self.radarControllerHeaderObj.read(self.fp)
1070 self.radarControllerHeaderObj.read(self.fp)
1072 self.processingHeaderObj.read(self.fp)
1071 self.processingHeaderObj.read(self.fp)
1073
1072
1074 self.firstHeaderSize = self.basicHeaderObj.size
1073 self.firstHeaderSize = self.basicHeaderObj.size
1075
1074
1076 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
1075 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
1077 if datatype == 0:
1076 if datatype == 0:
1078 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
1077 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
1079 elif datatype == 1:
1078 elif datatype == 1:
1080 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
1079 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
1081 elif datatype == 2:
1080 elif datatype == 2:
1082 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
1081 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
1083 elif datatype == 3:
1082 elif datatype == 3:
1084 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
1083 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
1085 elif datatype == 4:
1084 elif datatype == 4:
1086 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
1085 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
1087 elif datatype == 5:
1086 elif datatype == 5:
1088 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
1087 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
1089 else:
1088 else:
1090 raise ValueError, 'Data type was not defined'
1089 raise ValueError, 'Data type was not defined'
1091
1090
1092 self.dtype = datatype_str
1091 self.dtype = datatype_str
1093 #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
1092 #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
1094 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
1093 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
1095 # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
1094 # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
1096 # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
1095 # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
1097 self.getBlockDimension()
1096 self.getBlockDimension()
1098
1097
1099 def __verifyFile(self, filename, msgFlag=True):
1098 def __verifyFile(self, filename, msgFlag=True):
1100
1099
1101 msg = None
1100 msg = None
1102
1101
1103 try:
1102 try:
1104 fp = open(filename, 'rb')
1103 fp = open(filename, 'rb')
1105 except IOError:
1104 except IOError:
1106
1105
1107 if msgFlag:
1106 if msgFlag:
1108 print "[Reading] File %s can't be opened" % (filename)
1107 print "[Reading] File %s can't be opened" % (filename)
1109
1108
1110 return False
1109 return False
1111
1110
1112 currentPosition = fp.tell()
1111 currentPosition = fp.tell()
1113 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
1112 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
1114
1113
1115 if neededSize == 0:
1114 if neededSize == 0:
1116 basicHeaderObj = BasicHeader(LOCALTIME)
1115 basicHeaderObj = BasicHeader(LOCALTIME)
1117 systemHeaderObj = SystemHeader()
1116 systemHeaderObj = SystemHeader()
1118 radarControllerHeaderObj = RadarControllerHeader()
1117 radarControllerHeaderObj = RadarControllerHeader()
1119 processingHeaderObj = ProcessingHeader()
1118 processingHeaderObj = ProcessingHeader()
1120
1119
1121 if not( basicHeaderObj.read(fp) ):
1120 if not( basicHeaderObj.read(fp) ):
1122 fp.close()
1121 fp.close()
1123 return False
1122 return False
1124
1123
1125 if not( systemHeaderObj.read(fp) ):
1124 if not( systemHeaderObj.read(fp) ):
1126 fp.close()
1125 fp.close()
1127 return False
1126 return False
1128
1127
1129 if not( radarControllerHeaderObj.read(fp) ):
1128 if not( radarControllerHeaderObj.read(fp) ):
1130 fp.close()
1129 fp.close()
1131 return False
1130 return False
1132
1131
1133 if not( processingHeaderObj.read(fp) ):
1132 if not( processingHeaderObj.read(fp) ):
1134 fp.close()
1133 fp.close()
1135 return False
1134 return False
1136
1135
1137 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
1136 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
1138 else:
1137 else:
1139 msg = "[Reading] Skipping the file %s due to it hasn't enough data" %filename
1138 msg = "[Reading] Skipping the file %s due to it hasn't enough data" %filename
1140
1139
1141 fp.close()
1140 fp.close()
1142
1141
1143 fileSize = os.path.getsize(filename)
1142 fileSize = os.path.getsize(filename)
1144 currentSize = fileSize - currentPosition
1143 currentSize = fileSize - currentPosition
1145
1144
1146 if currentSize < neededSize:
1145 if currentSize < neededSize:
1147 if msgFlag and (msg != None):
1146 if msgFlag and (msg != None):
1148 print msg
1147 print msg
1149 return False
1148 return False
1150
1149
1151 return True
1150 return True
1152
1151
1153 def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True, include_path=False):
1152 def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True, include_path=False):
1154
1153
1155 path_empty = True
1154 path_empty = True
1156
1155
1157 dateList = []
1156 dateList = []
1158 pathList = []
1157 pathList = []
1159
1158
1160 multi_path = path.split(',')
1159 multi_path = path.split(',')
1161
1160
1162 if not walk:
1161 if not walk:
1163
1162
1164 for single_path in multi_path:
1163 for single_path in multi_path:
1165
1164
1166 if not os.path.isdir(single_path):
1165 if not os.path.isdir(single_path):
1167 continue
1166 continue
1168
1167
1169 fileList = glob.glob1(single_path, "*"+ext)
1168 fileList = glob.glob1(single_path, "*"+ext)
1170
1169
1171 if not fileList:
1170 if not fileList:
1172 continue
1171 continue
1173
1172
1174 path_empty = False
1173 path_empty = False
1175
1174
1176 fileList.sort()
1175 fileList.sort()
1177
1176
1178 for thisFile in fileList:
1177 for thisFile in fileList:
1179
1178
1180 if not os.path.isfile(os.path.join(single_path, thisFile)):
1179 if not os.path.isfile(os.path.join(single_path, thisFile)):
1181 continue
1180 continue
1182
1181
1183 if not isRadarFile(thisFile):
1182 if not isRadarFile(thisFile):
1184 continue
1183 continue
1185
1184
1186 if not isFileInDateRange(thisFile, startDate, endDate):
1185 if not isFileInDateRange(thisFile, startDate, endDate):
1187 continue
1186 continue
1188
1187
1189 thisDate = getDateFromRadarFile(thisFile)
1188 thisDate = getDateFromRadarFile(thisFile)
1190
1189
1191 if thisDate in dateList:
1190 if thisDate in dateList:
1192 continue
1191 continue
1193
1192
1194 dateList.append(thisDate)
1193 dateList.append(thisDate)
1195 pathList.append(single_path)
1194 pathList.append(single_path)
1196
1195
1197 else:
1196 else:
1198 for single_path in multi_path:
1197 for single_path in multi_path:
1199
1198
1200 if not os.path.isdir(single_path):
1199 if not os.path.isdir(single_path):
1201 continue
1200 continue
1202
1201
1203 dirList = []
1202 dirList = []
1204
1203
1205 for thisPath in os.listdir(single_path):
1204 for thisPath in os.listdir(single_path):
1206
1205
1207 if not os.path.isdir(os.path.join(single_path,thisPath)):
1206 if not os.path.isdir(os.path.join(single_path,thisPath)):
1208 continue
1207 continue
1209
1208
1210 if not isRadarFolder(thisPath):
1209 if not isRadarFolder(thisPath):
1211 continue
1210 continue
1212
1211
1213 if not isFolderInDateRange(thisPath, startDate, endDate):
1212 if not isFolderInDateRange(thisPath, startDate, endDate):
1214 continue
1213 continue
1215
1214
1216 dirList.append(thisPath)
1215 dirList.append(thisPath)
1217
1216
1218 if not dirList:
1217 if not dirList:
1219 continue
1218 continue
1220
1219
1221 dirList.sort()
1220 dirList.sort()
1222
1221
1223 for thisDir in dirList:
1222 for thisDir in dirList:
1224
1223
1225 datapath = os.path.join(single_path, thisDir, expLabel)
1224 datapath = os.path.join(single_path, thisDir, expLabel)
1226 fileList = glob.glob1(datapath, "*"+ext)
1225 fileList = glob.glob1(datapath, "*"+ext)
1227
1226
1228 if not fileList:
1227 if not fileList:
1229 continue
1228 continue
1230
1229
1231 path_empty = False
1230 path_empty = False
1232
1231
1233 thisDate = getDateFromRadarFolder(thisDir)
1232 thisDate = getDateFromRadarFolder(thisDir)
1234
1233
1235 pathList.append(datapath)
1234 pathList.append(datapath)
1236 dateList.append(thisDate)
1235 dateList.append(thisDate)
1237
1236
1238 dateList.sort()
1237 dateList.sort()
1239
1238
1240 if walk:
1239 if walk:
1241 pattern_path = os.path.join(multi_path[0], "[dYYYYDDD]", expLabel)
1240 pattern_path = os.path.join(multi_path[0], "[dYYYYDDD]", expLabel)
1242 else:
1241 else:
1243 pattern_path = multi_path[0]
1242 pattern_path = multi_path[0]
1244
1243
1245 if path_empty:
1244 if path_empty:
1246 print "[Reading] No *%s files in %s for %s to %s" %(ext, pattern_path, startDate, endDate)
1245 print "[Reading] No *%s files in %s for %s to %s" %(ext, pattern_path, startDate, endDate)
1247 else:
1246 else:
1248 if not dateList:
1247 if not dateList:
1249 print "[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" %(startDate, endDate, ext, path)
1248 print "[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" %(startDate, endDate, ext, path)
1250
1249
1251 if include_path:
1250 if include_path:
1252 return dateList, pathList
1251 return dateList, pathList
1253
1252
1254 return dateList
1253 return dateList
1255
1254
1256 def setup(self,
1255 def setup(self,
1257 path=None,
1256 path=None,
1258 startDate=None,
1257 startDate=None,
1259 endDate=None,
1258 endDate=None,
1260 startTime=datetime.time(0,0,0),
1259 startTime=datetime.time(0,0,0),
1261 endTime=datetime.time(23,59,59),
1260 endTime=datetime.time(23,59,59),
1262 set=None,
1261 set=None,
1263 expLabel = "",
1262 expLabel = "",
1264 ext = None,
1263 ext = None,
1265 online = False,
1264 online = False,
1266 delay = 60,
1265 delay = 60,
1267 walk = True,
1266 walk = True,
1268 getblock = False,
1267 getblock = False,
1269 nTxs = 1,
1268 nTxs = 1,
1270 realtime=False,
1269 realtime=False,
1271 blocksize=None,
1270 blocksize=None,
1272 blocktime=None,
1271 blocktime=None,
1273 queue=None,
1272 queue=None,
1274 skip=None,
1273 skip=None,
1275 cursor=None,
1274 cursor=None,
1276 warnings=True,
1275 warnings=True,
1277 verbose=True):
1276 verbose=True,
1278
1277 server=None):
1279 if path == None:
1278
1280 raise ValueError, "[Reading] The path is not valid"
1279 if server is not None:
1281
1280 server = kwargs.get('server', 'zmq.pipe')
1282 if ext == None:
1281 if 'tcp://' in server:
1283 ext = self.ext
1282 address = server
1284
1283 else:
1285 if online:
1284 address = 'ipc:///tmp/%s' % server
1286 print "[Reading] Searching files in online mode..."
1285 self.address = address
1287
1286 self.context = zmq.Context()
1288 for nTries in range( self.nTries ):
1287 self.receiver = self.context.socket(zmq.PULL)
1289 fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk, set=set)
1288 self.receiver.bind(self.address)
1290
1289 time.sleep(0.5)
1291 if fullpath:
1290 print '[Starting] ReceiverData from {}'.format(self.address)
1292 break
1291 else:
1293
1292 if path == None:
1294 print '[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
1293 raise ValueError, "[Reading] The path is not valid"
1295 sleep( self.delay )
1294
1296
1295 if ext == None:
1297 if not(fullpath):
1296 ext = self.ext
1298 print "[Reading] There 'isn't any valid file in %s" % path
1297
1299 return
1298 if online:
1300
1299 print "[Reading] Searching files in online mode..."
1301 self.year = year
1300
1302 self.doy = doy
1301 for nTries in range( self.nTries ):
1303 self.set = set - 1
1302 fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk, set=set)
1304 self.path = path
1303
1305 self.foldercounter = foldercounter
1304 if fullpath:
1306 last_set = None
1305 break
1306
1307 print '[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
1308 sleep( self.delay )
1309
1310 if not(fullpath):
1311 print "[Reading] There 'isn't any valid file in %s" % path
1312 return
1313
1314 self.year = year
1315 self.doy = doy
1316 self.set = set - 1
1317 self.path = path
1318 self.foldercounter = foldercounter
1319 last_set = None
1320 else:
1321 print "[Reading] Searching files in offline mode ..."
1322 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
1323 startTime=startTime, endTime=endTime,
1324 set=set, expLabel=expLabel, ext=ext,
1325 walk=walk, cursor=cursor,
1326 skip=skip, queue=queue)
1307
1327
1308 else:
1328 if not(pathList):
1309 print "[Reading] Searching files in offline mode ..."
1329 # print "[Reading] No *%s files in %s (%s - %s)"%(ext, path,
1310 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
1330 # datetime.datetime.combine(startDate,startTime).ctime(),
1311 startTime=startTime, endTime=endTime,
1331 # datetime.datetime.combine(endDate,endTime).ctime())
1312 set=set, expLabel=expLabel, ext=ext,
1313 walk=walk, cursor=cursor,
1314 skip=skip, queue=queue)
1315
1332
1316 if not(pathList):
1333 # sys.exit(-1)
1317 # print "[Reading] No *%s files in %s (%s - %s)"%(ext, path,
1318 # datetime.datetime.combine(startDate,startTime).ctime(),
1319 # datetime.datetime.combine(endDate,endTime).ctime())
1320
1334
1321 # sys.exit(-1)
1335 self.fileIndex = -1
1336 self.pathList = []
1337 self.filenameList = []
1338 return
1322
1339
1323 self.fileIndex = -1
1340 self.fileIndex = -1
1324 self.pathList = []
1341 self.pathList = pathList
1325 self.filenameList = []
1342 self.filenameList = filenameList
1326 return
1343 file_name = os.path.basename(filenameList[-1])
1327
1344 basename, ext = os.path.splitext(file_name)
1328 self.fileIndex = -1
1345 last_set = int(basename[-3:])
1329 self.pathList = pathList
1346
1330 self.filenameList = filenameList
1347 self.online = online
1331 file_name = os.path.basename(filenameList[-1])
1348 self.realtime = realtime
1332 basename, ext = os.path.splitext(file_name)
1349 self.delay = delay
1333 last_set = int(basename[-3:])
1350 ext = ext.lower()
1334
1351 self.ext = ext
1335 self.online = online
1352 self.getByBlock = getblock
1336 self.realtime = realtime
1353 self.nTxs = nTxs
1337 self.delay = delay
1354 self.startTime = startTime
1338 ext = ext.lower()
1355 self.endTime = endTime
1339 self.ext = ext
1356
1340 self.getByBlock = getblock
1357 #Added-----------------
1341 self.nTxs = nTxs
1358 self.selBlocksize = blocksize
1342 self.startTime = startTime
1359 self.selBlocktime = blocktime
1343 self.endTime = endTime
1360
1344
1361 # Verbose-----------
1345 #Added-----------------
1362 self.verbose = verbose
1346 self.selBlocksize = blocksize
1363 self.warnings = warnings
1347 self.selBlocktime = blocktime
1348
1349 # Verbose-----------
1350 self.verbose = verbose
1351 self.warnings = warnings
1352
1364
1353 if not(self.setNextFile()):
1365 if not(self.setNextFile()):
1354 if (startDate!=None) and (endDate!=None):
1366 if (startDate!=None) and (endDate!=None):
1355 print "[Reading] No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
1367 print "[Reading] No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
1356 elif startDate != None:
1368 elif startDate != None:
1357 print "[Reading] No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
1369 print "[Reading] No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
1358 else:
1370 else:
1359 print "[Reading] No files"
1371 print "[Reading] No files"
1360
1372
1361 self.fileIndex = -1
1373 self.fileIndex = -1
1362 self.pathList = []
1374 self.pathList = []
1363 self.filenameList = []
1375 self.filenameList = []
1364 return
1376 return
1365
1377
1366 # self.getBasicHeader()
1378 # self.getBasicHeader()
1367
1379
1368 if last_set != None:
1380 if last_set != None:
1369 self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
1381 self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
1370 return
1382 return
1371
1383
1372 def getBasicHeader(self):
1384 def getBasicHeader(self):
1373
1385
1374 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
1386 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
1375
1387
1376 self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
1388 self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
1377
1389
1378 self.dataOut.timeZone = self.basicHeaderObj.timeZone
1390 self.dataOut.timeZone = self.basicHeaderObj.timeZone
1379
1391
1380 self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
1392 self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
1381
1393
1382 self.dataOut.errorCount = self.basicHeaderObj.errorCount
1394 self.dataOut.errorCount = self.basicHeaderObj.errorCount
1383
1395
1384 self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
1396 self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
1385
1397
1386 self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
1398 self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
1387
1399
1388 # self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
1400 # self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
1389
1401
1390
1402
1391 def getFirstHeader(self):
1403 def getFirstHeader(self):
1392
1404
1393 raise NotImplementedError
1405 raise NotImplementedError
1394
1406
1395 def getData(self):
1407 def getData(self):
1396
1408
1397 raise NotImplementedError
1409 raise NotImplementedError
1398
1410
1399 def hasNotDataInBuffer(self):
1411 def hasNotDataInBuffer(self):
1400
1412
1401 raise NotImplementedError
1413 raise NotImplementedError
1402
1414
1403 def readBlock(self):
1415 def readBlock(self):
1404
1416
1405 raise NotImplementedError
1417 raise NotImplementedError
1406
1418
1407 def isEndProcess(self):
1419 def isEndProcess(self):
1408
1420
1409 return self.flagNoMoreFiles
1421 return self.flagNoMoreFiles
1410
1422
1411 def printReadBlocks(self):
1423 def printReadBlocks(self):
1412
1424
1413 print "[Reading] Number of read blocks per file %04d" %self.nReadBlocks
1425 print "[Reading] Number of read blocks per file %04d" %self.nReadBlocks
1414
1426
1415 def printTotalBlocks(self):
1427 def printTotalBlocks(self):
1416
1428
1417 print "[Reading] Number of read blocks %04d" %self.nTotalBlocks
1429 print "[Reading] Number of read blocks %04d" %self.nTotalBlocks
1418
1430
1419 def printNumberOfBlock(self):
1431 def printNumberOfBlock(self):
1420
1432
1421 if self.flagIsNewBlock:
1433 if self.flagIsNewBlock:
1422 print "[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
1434 print "[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
1423 self.processingHeaderObj.dataBlocksPerFile,
1435 self.processingHeaderObj.dataBlocksPerFile,
1424 self.dataOut.datatime.ctime())
1436 self.dataOut.datatime.ctime())
1425
1437
1426 def printInfo(self):
1438 def printInfo(self):
1427
1439
1428 if self.__printInfo == False:
1440 if self.__printInfo == False:
1429 return
1441 return
1430
1442
1431 self.basicHeaderObj.printInfo()
1443 self.basicHeaderObj.printInfo()
1432 self.systemHeaderObj.printInfo()
1444 self.systemHeaderObj.printInfo()
1433 self.radarControllerHeaderObj.printInfo()
1445 self.radarControllerHeaderObj.printInfo()
1434 self.processingHeaderObj.printInfo()
1446 self.processingHeaderObj.printInfo()
1435
1447
1436 self.__printInfo = False
1448 self.__printInfo = False
1437
1449
1438
1450
1439 def run(self,
1451 def run(self,
1440 path=None,
1452 path=None,
1441 startDate=None,
1453 startDate=None,
1442 endDate=None,
1454 endDate=None,
1443 startTime=datetime.time(0,0,0),
1455 startTime=datetime.time(0,0,0),
1444 endTime=datetime.time(23,59,59),
1456 endTime=datetime.time(23,59,59),
1445 set=None,
1457 set=None,
1446 expLabel = "",
1458 expLabel = "",
1447 ext = None,
1459 ext = None,
1448 online = False,
1460 online = False,
1449 delay = 60,
1461 delay = 60,
1450 walk = True,
1462 walk = True,
1451 getblock = False,
1463 getblock = False,
1452 nTxs = 1,
1464 nTxs = 1,
1453 realtime=False,
1465 realtime=False,
1454 blocksize=None,
1466 blocksize=None,
1455 blocktime=None,
1467 blocktime=None,
1456 queue=None,
1468 queue=None,
1457 skip=None,
1469 skip=None,
1458 cursor=None,
1470 cursor=None,
1459 warnings=True,
1471 warnings=True,
1472 server=None,
1460 verbose=True, **kwargs):
1473 verbose=True, **kwargs):
1461
1474
1462 if not(self.isConfig):
1475 if not(self.isConfig):
1463 # self.dataOut = dataOut
1476 # self.dataOut = dataOut
1464 self.setup( path=path,
1477 self.setup( path=path,
1465 startDate=startDate,
1478 startDate=startDate,
1466 endDate=endDate,
1479 endDate=endDate,
1467 startTime=startTime,
1480 startTime=startTime,
1468 endTime=endTime,
1481 endTime=endTime,
1469 set=set,
1482 set=set,
1470 expLabel=expLabel,
1483 expLabel=expLabel,
1471 ext=ext,
1484 ext=ext,
1472 online=online,
1485 online=online,
1473 delay=delay,
1486 delay=delay,
1474 walk=walk,
1487 walk=walk,
1475 getblock=getblock,
1488 getblock=getblock,
1476 nTxs=nTxs,
1489 nTxs=nTxs,
1477 realtime=realtime,
1490 realtime=realtime,
1478 blocksize=blocksize,
1491 blocksize=blocksize,
1479 blocktime=blocktime,
1492 blocktime=blocktime,
1480 queue=queue,
1493 queue=queue,
1481 skip=skip,
1494 skip=skip,
1482 cursor=cursor,
1495 cursor=cursor,
1483 warnings=warnings,
1496 warnings=warnings,
1497 server=None,
1484 verbose=verbose)
1498 verbose=verbose)
1485 self.isConfig = True
1499 self.isConfig = True
1486
1500 if self.server is None:
1487 self.getData()
1501 self.getData()
1502 else:
1503 self.getFromZMQ()
1488
1504
1489 class JRODataWriter(JRODataIO):
1505 class JRODataWriter(JRODataIO):
1490
1506
1491 """
1507 """
1492 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
1508 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
1493 de los datos siempre se realiza por bloques.
1509 de los datos siempre se realiza por bloques.
1494 """
1510 """
1495
1511
1496 blockIndex = 0
1512 blockIndex = 0
1497
1513
1498 path = None
1514 path = None
1499
1515
1500 setFile = None
1516 setFile = None
1501
1517
1502 profilesPerBlock = None
1518 profilesPerBlock = None
1503
1519
1504 blocksPerFile = None
1520 blocksPerFile = None
1505
1521
1506 nWriteBlocks = 0
1522 nWriteBlocks = 0
1507
1523
1508 fileDate = None
1524 fileDate = None
1509
1525
1510 def __init__(self, dataOut=None):
1526 def __init__(self, dataOut=None):
1511 raise NotImplementedError
1527 raise NotImplementedError
1512
1528
1513
1529
1514 def hasAllDataInBuffer(self):
1530 def hasAllDataInBuffer(self):
1515 raise NotImplementedError
1531 raise NotImplementedError
1516
1532
1517
1533
1518 def setBlockDimension(self):
1534 def setBlockDimension(self):
1519 raise NotImplementedError
1535 raise NotImplementedError
1520
1536
1521
1537
1522 def writeBlock(self):
1538 def writeBlock(self):
1523 raise NotImplementedError
1539 raise NotImplementedError
1524
1540
1525
1541
1526 def putData(self):
1542 def putData(self):
1527 raise NotImplementedError
1543 raise NotImplementedError
1528
1544
1529
1545
1530 def getProcessFlags(self):
1546 def getProcessFlags(self):
1531
1547
1532 processFlags = 0
1548 processFlags = 0
1533
1549
1534 dtype_index = get_dtype_index(self.dtype)
1550 dtype_index = get_dtype_index(self.dtype)
1535 procflag_dtype = get_procflag_dtype(dtype_index)
1551 procflag_dtype = get_procflag_dtype(dtype_index)
1536
1552
1537 processFlags += procflag_dtype
1553 processFlags += procflag_dtype
1538
1554
1539 if self.dataOut.flagDecodeData:
1555 if self.dataOut.flagDecodeData:
1540 processFlags += PROCFLAG.DECODE_DATA
1556 processFlags += PROCFLAG.DECODE_DATA
1541
1557
1542 if self.dataOut.flagDeflipData:
1558 if self.dataOut.flagDeflipData:
1543 processFlags += PROCFLAG.DEFLIP_DATA
1559 processFlags += PROCFLAG.DEFLIP_DATA
1544
1560
1545 if self.dataOut.code is not None:
1561 if self.dataOut.code is not None:
1546 processFlags += PROCFLAG.DEFINE_PROCESS_CODE
1562 processFlags += PROCFLAG.DEFINE_PROCESS_CODE
1547
1563
1548 if self.dataOut.nCohInt > 1:
1564 if self.dataOut.nCohInt > 1:
1549 processFlags += PROCFLAG.COHERENT_INTEGRATION
1565 processFlags += PROCFLAG.COHERENT_INTEGRATION
1550
1566
1551 if self.dataOut.type == "Spectra":
1567 if self.dataOut.type == "Spectra":
1552 if self.dataOut.nIncohInt > 1:
1568 if self.dataOut.nIncohInt > 1:
1553 processFlags += PROCFLAG.INCOHERENT_INTEGRATION
1569 processFlags += PROCFLAG.INCOHERENT_INTEGRATION
1554
1570
1555 if self.dataOut.data_dc is not None:
1571 if self.dataOut.data_dc is not None:
1556 processFlags += PROCFLAG.SAVE_CHANNELS_DC
1572 processFlags += PROCFLAG.SAVE_CHANNELS_DC
1557
1573
1558 if self.dataOut.flagShiftFFT:
1574 if self.dataOut.flagShiftFFT:
1559 processFlags += PROCFLAG.SHIFT_FFT_DATA
1575 processFlags += PROCFLAG.SHIFT_FFT_DATA
1560
1576
1561 return processFlags
1577 return processFlags
1562
1578
1563 def setBasicHeader(self):
1579 def setBasicHeader(self):
1564
1580
1565 self.basicHeaderObj.size = self.basicHeaderSize #bytes
1581 self.basicHeaderObj.size = self.basicHeaderSize #bytes
1566 self.basicHeaderObj.version = self.versionFile
1582 self.basicHeaderObj.version = self.versionFile
1567 self.basicHeaderObj.dataBlock = self.nTotalBlocks
1583 self.basicHeaderObj.dataBlock = self.nTotalBlocks
1568
1584
1569 utc = numpy.floor(self.dataOut.utctime)
1585 utc = numpy.floor(self.dataOut.utctime)
1570 milisecond = (self.dataOut.utctime - utc)* 1000.0
1586 milisecond = (self.dataOut.utctime - utc)* 1000.0
1571
1587
1572 self.basicHeaderObj.utc = utc
1588 self.basicHeaderObj.utc = utc
1573 self.basicHeaderObj.miliSecond = milisecond
1589 self.basicHeaderObj.miliSecond = milisecond
1574 self.basicHeaderObj.timeZone = self.dataOut.timeZone
1590 self.basicHeaderObj.timeZone = self.dataOut.timeZone
1575 self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
1591 self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
1576 self.basicHeaderObj.errorCount = self.dataOut.errorCount
1592 self.basicHeaderObj.errorCount = self.dataOut.errorCount
1577
1593
1578 def setFirstHeader(self):
1594 def setFirstHeader(self):
1579 """
1595 """
1580 Obtiene una copia del First Header
1596 Obtiene una copia del First Header
1581
1597
1582 Affected:
1598 Affected:
1583
1599
1584 self.basicHeaderObj
1600 self.basicHeaderObj
1585 self.systemHeaderObj
1601 self.systemHeaderObj
1586 self.radarControllerHeaderObj
1602 self.radarControllerHeaderObj
1587 self.processingHeaderObj self.
1603 self.processingHeaderObj self.
1588
1604
1589 Return:
1605 Return:
1590 None
1606 None
1591 """
1607 """
1592
1608
1593 raise NotImplementedError
1609 raise NotImplementedError
1594
1610
1595 def __writeFirstHeader(self):
1611 def __writeFirstHeader(self):
1596 """
1612 """
1597 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1613 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1598
1614
1599 Affected:
1615 Affected:
1600 __dataType
1616 __dataType
1601
1617
1602 Return:
1618 Return:
1603 None
1619 None
1604 """
1620 """
1605
1621
1606 # CALCULAR PARAMETROS
1622 # CALCULAR PARAMETROS
1607
1623
1608 sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
1624 sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
1609 self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
1625 self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
1610
1626
1611 self.basicHeaderObj.write(self.fp)
1627 self.basicHeaderObj.write(self.fp)
1612 self.systemHeaderObj.write(self.fp)
1628 self.systemHeaderObj.write(self.fp)
1613 self.radarControllerHeaderObj.write(self.fp)
1629 self.radarControllerHeaderObj.write(self.fp)
1614 self.processingHeaderObj.write(self.fp)
1630 self.processingHeaderObj.write(self.fp)
1615
1631
1616 def __setNewBlock(self):
1632 def __setNewBlock(self):
1617 """
1633 """
1618 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1634 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1619
1635
1620 Return:
1636 Return:
1621 0 : si no pudo escribir nada
1637 0 : si no pudo escribir nada
1622 1 : Si escribio el Basic el First Header
1638 1 : Si escribio el Basic el First Header
1623 """
1639 """
1624 if self.fp == None:
1640 if self.fp == None:
1625 self.setNextFile()
1641 self.setNextFile()
1626
1642
1627 if self.flagIsNewFile:
1643 if self.flagIsNewFile:
1628 return 1
1644 return 1
1629
1645
1630 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
1646 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
1631 self.basicHeaderObj.write(self.fp)
1647 self.basicHeaderObj.write(self.fp)
1632 return 1
1648 return 1
1633
1649
1634 if not( self.setNextFile() ):
1650 if not( self.setNextFile() ):
1635 return 0
1651 return 0
1636
1652
1637 return 1
1653 return 1
1638
1654
1639
1655
1640 def writeNextBlock(self):
1656 def writeNextBlock(self):
1641 """
1657 """
1642 Selecciona el bloque siguiente de datos y los escribe en un file
1658 Selecciona el bloque siguiente de datos y los escribe en un file
1643
1659
1644 Return:
1660 Return:
1645 0 : Si no hizo pudo escribir el bloque de datos
1661 0 : Si no hizo pudo escribir el bloque de datos
1646 1 : Si no pudo escribir el bloque de datos
1662 1 : Si no pudo escribir el bloque de datos
1647 """
1663 """
1648 if not( self.__setNewBlock() ):
1664 if not( self.__setNewBlock() ):
1649 return 0
1665 return 0
1650
1666
1651 self.writeBlock()
1667 self.writeBlock()
1652
1668
1653 print "[Writing] Block No. %d/%d" %(self.blockIndex,
1669 print "[Writing] Block No. %d/%d" %(self.blockIndex,
1654 self.processingHeaderObj.dataBlocksPerFile)
1670 self.processingHeaderObj.dataBlocksPerFile)
1655
1671
1656 return 1
1672 return 1
1657
1673
1658 def setNextFile(self):
1674 def setNextFile(self):
1659 """
1675 """
1660 Determina el siguiente file que sera escrito
1676 Determina el siguiente file que sera escrito
1661
1677
1662 Affected:
1678 Affected:
1663 self.filename
1679 self.filename
1664 self.subfolder
1680 self.subfolder
1665 self.fp
1681 self.fp
1666 self.setFile
1682 self.setFile
1667 self.flagIsNewFile
1683 self.flagIsNewFile
1668
1684
1669 Return:
1685 Return:
1670 0 : Si el archivo no puede ser escrito
1686 0 : Si el archivo no puede ser escrito
1671 1 : Si el archivo esta listo para ser escrito
1687 1 : Si el archivo esta listo para ser escrito
1672 """
1688 """
1673 ext = self.ext
1689 ext = self.ext
1674 path = self.path
1690 path = self.path
1675
1691
1676 if self.fp != None:
1692 if self.fp != None:
1677 self.fp.close()
1693 self.fp.close()
1678
1694
1679 timeTuple = time.localtime( self.dataOut.utctime)
1695 timeTuple = time.localtime( self.dataOut.utctime)
1680 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1696 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1681
1697
1682 fullpath = os.path.join( path, subfolder )
1698 fullpath = os.path.join( path, subfolder )
1683 setFile = self.setFile
1699 setFile = self.setFile
1684
1700
1685 if not( os.path.exists(fullpath) ):
1701 if not( os.path.exists(fullpath) ):
1686 os.mkdir(fullpath)
1702 os.mkdir(fullpath)
1687 setFile = -1 #inicializo mi contador de seteo
1703 setFile = -1 #inicializo mi contador de seteo
1688 else:
1704 else:
1689 filesList = os.listdir( fullpath )
1705 filesList = os.listdir( fullpath )
1690 if len( filesList ) > 0:
1706 if len( filesList ) > 0:
1691 filesList = sorted( filesList, key=str.lower )
1707 filesList = sorted( filesList, key=str.lower )
1692 filen = filesList[-1]
1708 filen = filesList[-1]
1693 # el filename debera tener el siguiente formato
1709 # el filename debera tener el siguiente formato
1694 # 0 1234 567 89A BCDE (hex)
1710 # 0 1234 567 89A BCDE (hex)
1695 # x YYYY DDD SSS .ext
1711 # x YYYY DDD SSS .ext
1696 if isNumber( filen[8:11] ):
1712 if isNumber( filen[8:11] ):
1697 setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1713 setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1698 else:
1714 else:
1699 setFile = -1
1715 setFile = -1
1700 else:
1716 else:
1701 setFile = -1 #inicializo mi contador de seteo
1717 setFile = -1 #inicializo mi contador de seteo
1702
1718
1703 setFile += 1
1719 setFile += 1
1704
1720
1705 #If this is a new day it resets some values
1721 #If this is a new day it resets some values
1706 if self.dataOut.datatime.date() > self.fileDate:
1722 if self.dataOut.datatime.date() > self.fileDate:
1707 setFile = 0
1723 setFile = 0
1708 self.nTotalBlocks = 0
1724 self.nTotalBlocks = 0
1709
1725
1710 filen = '%s%4.4d%3.3d%3.3d%s' % (self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
1726 filen = '%s%4.4d%3.3d%3.3d%s' % (self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
1711
1727
1712 filename = os.path.join( path, subfolder, filen )
1728 filename = os.path.join( path, subfolder, filen )
1713
1729
1714 fp = open( filename,'wb' )
1730 fp = open( filename,'wb' )
1715
1731
1716 self.blockIndex = 0
1732 self.blockIndex = 0
1717
1733
1718 #guardando atributos
1734 #guardando atributos
1719 self.filename = filename
1735 self.filename = filename
1720 self.subfolder = subfolder
1736 self.subfolder = subfolder
1721 self.fp = fp
1737 self.fp = fp
1722 self.setFile = setFile
1738 self.setFile = setFile
1723 self.flagIsNewFile = 1
1739 self.flagIsNewFile = 1
1724 self.fileDate = self.dataOut.datatime.date()
1740 self.fileDate = self.dataOut.datatime.date()
1725
1741
1726 self.setFirstHeader()
1742 self.setFirstHeader()
1727
1743
1728 print '[Writing] Opening file: %s'%self.filename
1744 print '[Writing] Opening file: %s'%self.filename
1729
1745
1730 self.__writeFirstHeader()
1746 self.__writeFirstHeader()
1731
1747
1732 return 1
1748 return 1
1733
1749
1734 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4):
1750 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4):
1735 """
1751 """
1736 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1752 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1737
1753
1738 Inputs:
1754 Inputs:
1739 path : directory where data will be saved
1755 path : directory where data will be saved
1740 profilesPerBlock : number of profiles per block
1756 profilesPerBlock : number of profiles per block
1741 set : initial file set
1757 set : initial file set
1742 datatype : An integer number that defines data type:
1758 datatype : An integer number that defines data type:
1743 0 : int8 (1 byte)
1759 0 : int8 (1 byte)
1744 1 : int16 (2 bytes)
1760 1 : int16 (2 bytes)
1745 2 : int32 (4 bytes)
1761 2 : int32 (4 bytes)
1746 3 : int64 (8 bytes)
1762 3 : int64 (8 bytes)
1747 4 : float32 (4 bytes)
1763 4 : float32 (4 bytes)
1748 5 : double64 (8 bytes)
1764 5 : double64 (8 bytes)
1749
1765
1750 Return:
1766 Return:
1751 0 : Si no realizo un buen seteo
1767 0 : Si no realizo un buen seteo
1752 1 : Si realizo un buen seteo
1768 1 : Si realizo un buen seteo
1753 """
1769 """
1754
1770
1755 if ext == None:
1771 if ext == None:
1756 ext = self.ext
1772 ext = self.ext
1757
1773
1758 self.ext = ext.lower()
1774 self.ext = ext.lower()
1759
1775
1760 self.path = path
1776 self.path = path
1761
1777
1762 if set is None:
1778 if set is None:
1763 self.setFile = -1
1779 self.setFile = -1
1764 else:
1780 else:
1765 self.setFile = set - 1
1781 self.setFile = set - 1
1766
1782
1767 self.blocksPerFile = blocksPerFile
1783 self.blocksPerFile = blocksPerFile
1768
1784
1769 self.profilesPerBlock = profilesPerBlock
1785 self.profilesPerBlock = profilesPerBlock
1770
1786
1771 self.dataOut = dataOut
1787 self.dataOut = dataOut
1772 self.fileDate = self.dataOut.datatime.date()
1788 self.fileDate = self.dataOut.datatime.date()
1773 #By default
1789 #By default
1774 self.dtype = self.dataOut.dtype
1790 self.dtype = self.dataOut.dtype
1775
1791
1776 if datatype is not None:
1792 if datatype is not None:
1777 self.dtype = get_numpy_dtype(datatype)
1793 self.dtype = get_numpy_dtype(datatype)
1778
1794
1779 if not(self.setNextFile()):
1795 if not(self.setNextFile()):
1780 print "[Writing] There isn't a next file"
1796 print "[Writing] There isn't a next file"
1781 return 0
1797 return 0
1782
1798
1783 self.setBlockDimension()
1799 self.setBlockDimension()
1784
1800
1785 return 1
1801 return 1
1786
1802
1787 def run(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4, **kwargs):
1803 def run(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4, **kwargs):
1788
1804
1789 if not(self.isConfig):
1805 if not(self.isConfig):
1790
1806
1791 self.setup(dataOut, path, blocksPerFile, profilesPerBlock=profilesPerBlock, set=set, ext=ext, datatype=datatype, **kwargs)
1807 self.setup(dataOut, path, blocksPerFile, profilesPerBlock=profilesPerBlock, set=set, ext=ext, datatype=datatype, **kwargs)
1792 self.isConfig = True
1808 self.isConfig = True
1793
1809
1794 self.putData()
1810 self.putData()
Show file before | Show file after | Hide comments
@@ -1,637 +1,644
1 '''
1 '''
2 Created on Jul 2, 2014
2 Created on Jul 2, 2014
3
3
4 @author: roj-idl71
4 @author: roj-idl71
5 '''
5 '''
6
6
7 import numpy
7 import numpy
8
8
9 from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
9 from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
10 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
10 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
11 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
11 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
12 from schainpy.model.data.jrodata import Voltage
12 from schainpy.model.data.jrodata import Voltage
13 import zmq
13 # from _sha import blocksize
14 # from _sha import blocksize
14
15
15 class VoltageReader(JRODataReader, ProcessingUnit):
16 class VoltageReader(JRODataReader, ProcessingUnit):
16 """
17 """
17 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
18 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
18 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
19 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
19 perfiles*alturas*canales) son almacenados en la variable "buffer".
20 perfiles*alturas*canales) son almacenados en la variable "buffer".
20
21
21 perfiles * alturas * canales
22 perfiles * alturas * canales
22
23
23 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
24 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
24 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
25 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
25 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
26 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
26 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
27 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
27
28
28 Example:
29 Example:
29
30
30 dpath = "/home/myuser/data"
31 dpath = "/home/myuser/data"
31
32
32 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
33 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
33
34
34 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
35 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
35
36
36 readerObj = VoltageReader()
37 readerObj = VoltageReader()
37
38
38 readerObj.setup(dpath, startTime, endTime)
39 readerObj.setup(dpath, startTime, endTime)
39
40
40 while(True):
41 while(True):
41
42
42 #to get one profile
43 #to get one profile
43 profile = readerObj.getData()
44 profile = readerObj.getData()
44
45
45 #print the profile
46 #print the profile
46 print profile
47 print profile
47
48
48 #If you want to see all datablock
49 #If you want to see all datablock
49 print readerObj.datablock
50 print readerObj.datablock
50
51
51 if readerObj.flagNoMoreFiles:
52 if readerObj.flagNoMoreFiles:
52 break
53 break
53
54
54 """
55 """
55
56
56 ext = ".r"
57 ext = ".r"
57
58
58 optchar = "D"
59 optchar = "D"
59 dataOut = None
60 dataOut = None
60
61
61 def __init__(self, **kwargs):
62 def __init__(self, **kwargs):
62 """
63 """
63 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
64 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
64
65
65 Input:
66 Input:
66 dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para
67 dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para
67 almacenar un perfil de datos cada vez que se haga un requerimiento
68 almacenar un perfil de datos cada vez que se haga un requerimiento
68 (getData). El perfil sera obtenido a partir del buffer de datos,
69 (getData). El perfil sera obtenido a partir del buffer de datos,
69 si el buffer esta vacio se hara un nuevo proceso de lectura de un
70 si el buffer esta vacio se hara un nuevo proceso de lectura de un
70 bloque de datos.
71 bloque de datos.
71 Si este parametro no es pasado se creara uno internamente.
72 Si este parametro no es pasado se creara uno internamente.
72
73
73 Variables afectadas:
74 Variables afectadas:
74 self.dataOut
75 self.dataOut
75
76
76 Return:
77 Return:
77 None
78 None
78 """
79 """
79
80
80 ProcessingUnit.__init__(self, **kwargs)
81 ProcessingUnit.__init__(self, **kwargs)
81
82
82 self.isConfig = False
83 self.isConfig = False
83
84
84 self.datablock = None
85 self.datablock = None
85
86
86 self.utc = 0
87 self.utc = 0
87
88
88 self.ext = ".r"
89 self.ext = ".r"
89
90
90 self.optchar = "D"
91 self.optchar = "D"
91
92
92 self.basicHeaderObj = BasicHeader(LOCALTIME)
93 self.basicHeaderObj = BasicHeader(LOCALTIME)
93
94
94 self.systemHeaderObj = SystemHeader()
95 self.systemHeaderObj = SystemHeader()
95
96
96 self.radarControllerHeaderObj = RadarControllerHeader()
97 self.radarControllerHeaderObj = RadarControllerHeader()
97
98
98 self.processingHeaderObj = ProcessingHeader()
99 self.processingHeaderObj = ProcessingHeader()
99
100
100 self.online = 0
101 self.online = 0
101
102
102 self.fp = None
103 self.fp = None
103
104
104 self.idFile = None
105 self.idFile = None
105
106
106 self.dtype = None
107 self.dtype = None
107
108
108 self.fileSizeByHeader = None
109 self.fileSizeByHeader = None
109
110
110 self.filenameList = []
111 self.filenameList = []
111
112
112 self.filename = None
113 self.filename = None
113
114
114 self.fileSize = None
115 self.fileSize = None
115
116
116 self.firstHeaderSize = 0
117 self.firstHeaderSize = 0
117
118
118 self.basicHeaderSize = 24
119 self.basicHeaderSize = 24
119
120
120 self.pathList = []
121 self.pathList = []
121
122
122 self.filenameList = []
123 self.filenameList = []
123
124
124 self.lastUTTime = 0
125 self.lastUTTime = 0
125
126
126 self.maxTimeStep = 30
127 self.maxTimeStep = 30
127
128
128 self.flagNoMoreFiles = 0
129 self.flagNoMoreFiles = 0
129
130
130 self.set = 0
131 self.set = 0
131
132
132 self.path = None
133 self.path = None
133
134
134 self.profileIndex = 2**32-1
135 self.profileIndex = 2**32-1
135
136
136 self.delay = 3 #seconds
137 self.delay = 3 #seconds
137
138
138 self.nTries = 3 #quantity tries
139 self.nTries = 3 #quantity tries
139
140
140 self.nFiles = 3 #number of files for searching
141 self.nFiles = 3 #number of files for searching
141
142
142 self.nReadBlocks = 0
143 self.nReadBlocks = 0
143
144
144 self.flagIsNewFile = 1
145 self.flagIsNewFile = 1
145
146
146 self.__isFirstTimeOnline = 1
147 self.__isFirstTimeOnline = 1
147
148
148 # self.ippSeconds = 0
149 # self.ippSeconds = 0
149
150
150 self.flagDiscontinuousBlock = 0
151 self.flagDiscontinuousBlock = 0
151
152
152 self.flagIsNewBlock = 0
153 self.flagIsNewBlock = 0
153
154
154 self.nTotalBlocks = 0
155 self.nTotalBlocks = 0
155
156
156 self.blocksize = 0
157 self.blocksize = 0
157
158
158 self.dataOut = self.createObjByDefault()
159 self.dataOut = self.createObjByDefault()
159
160
160 self.nTxs = 1
161 self.nTxs = 1
161
162
162 self.txIndex = 0
163 self.txIndex = 0
163
164
164 def createObjByDefault(self):
165 def createObjByDefault(self):
165
166
166 dataObj = Voltage()
167 dataObj = Voltage()
167
168
168 return dataObj
169 return dataObj
169
170
170 def __hasNotDataInBuffer(self):
171 def __hasNotDataInBuffer(self):
171
172
172 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock*self.nTxs:
173 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock*self.nTxs:
173 return 1
174 return 1
174
175
175 return 0
176 return 0
176
177
177
178
178 def getBlockDimension(self):
179 def getBlockDimension(self):
179 """
180 """
180 Obtiene la cantidad de puntos a leer por cada bloque de datos
181 Obtiene la cantidad de puntos a leer por cada bloque de datos
181
182
182 Affected:
183 Affected:
183 self.blocksize
184 self.blocksize
184
185
185 Return:
186 Return:
186 None
187 None
187 """
188 """
188 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
189 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
189 self.blocksize = pts2read
190 self.blocksize = pts2read
190
191
191
192
192 def readBlock(self):
193 def readBlock(self):
193 """
194 """
194 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
195 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
195 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
196 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
196 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
197 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
197 es seteado a 0
198 es seteado a 0
198
199
199 Inputs:
200 Inputs:
200 None
201 None
201
202
202 Return:
203 Return:
203 None
204 None
204
205
205 Affected:
206 Affected:
206 self.profileIndex
207 self.profileIndex
207 self.datablock
208 self.datablock
208 self.flagIsNewFile
209 self.flagIsNewFile
209 self.flagIsNewBlock
210 self.flagIsNewBlock
210 self.nTotalBlocks
211 self.nTotalBlocks
211
212
212 Exceptions:
213 Exceptions:
213 Si un bloque leido no es un bloque valido
214 Si un bloque leido no es un bloque valido
214 """
215 """
215 current_pointer_location = self.fp.tell()
216 current_pointer_location = self.fp.tell()
216 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
217 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
217
218
218 try:
219 try:
219 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
220 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
220 except:
221 except:
221 #print "The read block (%3d) has not enough data" %self.nReadBlocks
222 #print "The read block (%3d) has not enough data" %self.nReadBlocks
222
223
223 if self.waitDataBlock(pointer_location=current_pointer_location):
224 if self.waitDataBlock(pointer_location=current_pointer_location):
224 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
225 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
225 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
226 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
226 # return 0
227 # return 0
227
228
228 #Dimensions : nChannels, nProfiles, nSamples
229 #Dimensions : nChannels, nProfiles, nSamples
229
230
230 junk = numpy.transpose(junk, (2,0,1))
231 junk = numpy.transpose(junk, (2,0,1))
231 self.datablock = junk['real'] + junk['imag']*1j
232 self.datablock = junk['real'] + junk['imag']*1j
232
233
233 self.profileIndex = 0
234 self.profileIndex = 0
234
235
235 self.flagIsNewFile = 0
236 self.flagIsNewFile = 0
236 self.flagIsNewBlock = 1
237 self.flagIsNewBlock = 1
237
238
238 self.nTotalBlocks += 1
239 self.nTotalBlocks += 1
239 self.nReadBlocks += 1
240 self.nReadBlocks += 1
240
241
241 return 1
242 return 1
242
243
243 def getFirstHeader(self):
244 def getFirstHeader(self):
244
245
245 self.getBasicHeader()
246 self.getBasicHeader()
246
247
247 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
248 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
248
249
249 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
250 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
250
251
251 if self.nTxs > 1:
252 if self.nTxs > 1:
252 self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
253 self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
253
254
254 #Time interval and code are propierties of dataOut. Its value depends of radarControllerHeaderObj.
255 #Time interval and code are propierties of dataOut. Its value depends of radarControllerHeaderObj.
255
256
256 # self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt
257 # self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt
257 #
258 #
258 # if self.radarControllerHeaderObj.code is not None:
259 # if self.radarControllerHeaderObj.code is not None:
259 #
260 #
260 # self.dataOut.nCode = self.radarControllerHeaderObj.nCode
261 # self.dataOut.nCode = self.radarControllerHeaderObj.nCode
261 #
262 #
262 # self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
263 # self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
263 #
264 #
264 # self.dataOut.code = self.radarControllerHeaderObj.code
265 # self.dataOut.code = self.radarControllerHeaderObj.code
265
266
266 self.dataOut.dtype = self.dtype
267 self.dataOut.dtype = self.dtype
267
268
268 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
269 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
269
270
270 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
271 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
271
272
272 self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
273 self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
273
274
274 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
275 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
275
276
276 self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
277 self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
277
278
278 self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data no esta sin flip
279 self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data no esta sin flip
279
280
280 self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
281 self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
281
282
282 def reshapeData(self):
283 def reshapeData(self):
283
284
284 if self.nTxs < 0:
285 if self.nTxs < 0:
285 return
286 return
286
287
287 if self.nTxs == 1:
288 if self.nTxs == 1:
288 return
289 return
289
290
290 if self.nTxs < 1 and self.processingHeaderObj.profilesPerBlock % (1./self.nTxs) != 0:
291 if self.nTxs < 1 and self.processingHeaderObj.profilesPerBlock % (1./self.nTxs) != 0:
291 raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" %(1./self.nTxs, self.processingHeaderObj.profilesPerBlock)
292 raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" %(1./self.nTxs, self.processingHeaderObj.profilesPerBlock)
292
293
293 if self.nTxs > 1 and self.processingHeaderObj.nHeights % self.nTxs != 0:
294 if self.nTxs > 1 and self.processingHeaderObj.nHeights % self.nTxs != 0:
294 raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" %(self.nTxs, self.processingHeaderObj.nHeights)
295 raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" %(self.nTxs, self.processingHeaderObj.nHeights)
295
296
296 self.datablock = self.datablock.reshape((self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock*self.nTxs, self.processingHeaderObj.nHeights/self.nTxs))
297 self.datablock = self.datablock.reshape((self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock*self.nTxs, self.processingHeaderObj.nHeights/self.nTxs))
297
298
298 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
299 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
299 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights/self.nTxs) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
300 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights/self.nTxs) *self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
300 self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
301 self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
301
302
302 return
303 return
303
304
305
306 def getFromZMQ(self):
307 self.dataOut = self.receiver.recv_pyobj()
308 print '[Receiving] {} - {}'.format(self.dataOut.type,
309 self.dataOut.datatime.ctime())
310
304 def getData(self):
311 def getData(self):
305 """
312 """
306 getData obtiene una unidad de datos del buffer de lectura, un perfil, y la copia al objeto self.dataOut
313 getData obtiene una unidad de datos del buffer de lectura, un perfil, y la copia al objeto self.dataOut
307 del tipo "Voltage" con todos los parametros asociados a este (metadata). cuando no hay datos
314 del tipo "Voltage" con todos los parametros asociados a este (metadata). cuando no hay datos
308 en el buffer de lectura es necesario hacer una nueva lectura de los bloques de datos usando
315 en el buffer de lectura es necesario hacer una nueva lectura de los bloques de datos usando
309 "readNextBlock"
316 "readNextBlock"
310
317
311 Ademas incrementa el contador del buffer "self.profileIndex" en 1.
318 Ademas incrementa el contador del buffer "self.profileIndex" en 1.
312
319
313 Return:
320 Return:
314
321
315 Si el flag self.getByBlock ha sido seteado el bloque completo es copiado a self.dataOut y el self.profileIndex
322 Si el flag self.getByBlock ha sido seteado el bloque completo es copiado a self.dataOut y el self.profileIndex
316 es igual al total de perfiles leidos desde el archivo.
323 es igual al total de perfiles leidos desde el archivo.
317
324
318 Si self.getByBlock == False:
325 Si self.getByBlock == False:
319
326
320 self.dataOut.data = buffer[:, thisProfile, :]
327 self.dataOut.data = buffer[:, thisProfile, :]
321
328
322 shape = [nChannels, nHeis]
329 shape = [nChannels, nHeis]
323
330
324 Si self.getByBlock == True:
331 Si self.getByBlock == True:
325
332
326 self.dataOut.data = buffer[:, :, :]
333 self.dataOut.data = buffer[:, :, :]
327
334
328 shape = [nChannels, nProfiles, nHeis]
335 shape = [nChannels, nProfiles, nHeis]
329
336
330 Variables afectadas:
337 Variables afectadas:
331 self.dataOut
338 self.dataOut
332 self.profileIndex
339 self.profileIndex
333
340
334 Affected:
341 Affected:
335 self.dataOut
342 self.dataOut
336 self.profileIndex
343 self.profileIndex
337 self.flagDiscontinuousBlock
344 self.flagDiscontinuousBlock
338 self.flagIsNewBlock
345 self.flagIsNewBlock
339 """
346 """
340
347
341 if self.flagNoMoreFiles:
348 if self.flagNoMoreFiles:
342 self.dataOut.flagNoData = True
349 self.dataOut.flagNoData = True
343 print 'Process finished'
350 print 'Process finished'
344 return 0
351 return 0
345
352
346 self.flagDiscontinuousBlock = 0
353 self.flagDiscontinuousBlock = 0
347 self.flagIsNewBlock = 0
354 self.flagIsNewBlock = 0
348
355
349 if self.__hasNotDataInBuffer():
356 if self.__hasNotDataInBuffer():
350
357
351 if not( self.readNextBlock() ):
358 if not( self.readNextBlock() ):
352 return 0
359 return 0
353
360
354 self.getFirstHeader()
361 self.getFirstHeader()
355
362
356 self.reshapeData()
363 self.reshapeData()
357
364
358 if self.datablock is None:
365 if self.datablock is None:
359 self.dataOut.flagNoData = True
366 self.dataOut.flagNoData = True
360 return 0
367 return 0
361
368
362 if not self.getByBlock:
369 if not self.getByBlock:
363
370
364 """
371 """
365 Return profile by profile
372 Return profile by profile
366
373
367 If nTxs > 1 then one profile is divided by nTxs and number of total
374 If nTxs > 1 then one profile is divided by nTxs and number of total
368 blocks is increased by nTxs (nProfiles *= nTxs)
375 blocks is increased by nTxs (nProfiles *= nTxs)
369 """
376 """
370 self.dataOut.flagDataAsBlock = False
377 self.dataOut.flagDataAsBlock = False
371 self.dataOut.data = self.datablock[:,self.profileIndex,:]
378 self.dataOut.data = self.datablock[:,self.profileIndex,:]
372 self.dataOut.profileIndex = self.profileIndex
379 self.dataOut.profileIndex = self.profileIndex
373
380
374 self.profileIndex += 1
381 self.profileIndex += 1
375
382
376 # elif self.selBlocksize==None or self.selBlocksize==self.dataOut.nProfiles:
383 # elif self.selBlocksize==None or self.selBlocksize==self.dataOut.nProfiles:
377 # """
384 # """
378 # Return all block
385 # Return all block
379 # """
386 # """
380 # self.dataOut.flagDataAsBlock = True
387 # self.dataOut.flagDataAsBlock = True
381 # self.dataOut.data = self.datablock
388 # self.dataOut.data = self.datablock
382 # self.dataOut.profileIndex = self.dataOut.nProfiles - 1
389 # self.dataOut.profileIndex = self.dataOut.nProfiles - 1
383 #
390 #
384 # self.profileIndex = self.dataOut.nProfiles
391 # self.profileIndex = self.dataOut.nProfiles
385
392
386 else:
393 else:
387 """
394 """
388 Return a block
395 Return a block
389 """
396 """
390 if self.selBlocksize == None: self.selBlocksize = self.dataOut.nProfiles
397 if self.selBlocksize == None: self.selBlocksize = self.dataOut.nProfiles
391 if self.selBlocktime != None:
398 if self.selBlocktime != None:
392 if self.dataOut.nCohInt is not None:
399 if self.dataOut.nCohInt is not None:
393 nCohInt = self.dataOut.nCohInt
400 nCohInt = self.dataOut.nCohInt
394 else:
401 else:
395 nCohInt = 1
402 nCohInt = 1
396 self.selBlocksize = int(self.dataOut.nProfiles*round(self.selBlocktime/(nCohInt*self.dataOut.ippSeconds*self.dataOut.nProfiles)))
403 self.selBlocksize = int(self.dataOut.nProfiles*round(self.selBlocktime/(nCohInt*self.dataOut.ippSeconds*self.dataOut.nProfiles)))
397
404
398 self.dataOut.data = self.datablock[:,self.profileIndex:self.profileIndex+self.selBlocksize,:]
405 self.dataOut.data = self.datablock[:,self.profileIndex:self.profileIndex+self.selBlocksize,:]
399 self.profileIndex += self.selBlocksize
406 self.profileIndex += self.selBlocksize
400 datasize = self.dataOut.data.shape[1]
407 datasize = self.dataOut.data.shape[1]
401
408
402 if datasize < self.selBlocksize:
409 if datasize < self.selBlocksize:
403 buffer = numpy.zeros((self.dataOut.data.shape[0],self.selBlocksize,self.dataOut.data.shape[2]), dtype = 'complex')
410 buffer = numpy.zeros((self.dataOut.data.shape[0],self.selBlocksize,self.dataOut.data.shape[2]), dtype = 'complex')
404 buffer[:,:datasize,:] = self.dataOut.data
411 buffer[:,:datasize,:] = self.dataOut.data
405
412
406 while datasize < self.selBlocksize: #Not enough profiles to fill the block
413 while datasize < self.selBlocksize: #Not enough profiles to fill the block
407 if not( self.readNextBlock() ):
414 if not( self.readNextBlock() ):
408 return 0
415 return 0
409 self.getFirstHeader()
416 self.getFirstHeader()
410 self.reshapeData()
417 self.reshapeData()
411 if self.datablock is None:
418 if self.datablock is None:
412 self.dataOut.flagNoData = True
419 self.dataOut.flagNoData = True
413 return 0
420 return 0
414 #stack data
421 #stack data
415 blockIndex = self.selBlocksize - datasize
422 blockIndex = self.selBlocksize - datasize
416 datablock1 = self.datablock[:,:blockIndex,:]
423 datablock1 = self.datablock[:,:blockIndex,:]
417
424
418 buffer[:,datasize:datasize+datablock1.shape[1],:] = datablock1
425 buffer[:,datasize:datasize+datablock1.shape[1],:] = datablock1
419 datasize += datablock1.shape[1]
426 datasize += datablock1.shape[1]
420
427
421 self.dataOut.data = buffer
428 self.dataOut.data = buffer
422 self.profileIndex = blockIndex
429 self.profileIndex = blockIndex
423
430
424 self.dataOut.flagDataAsBlock = True
431 self.dataOut.flagDataAsBlock = True
425 self.dataOut.nProfiles = self.dataOut.data.shape[1]
432 self.dataOut.nProfiles = self.dataOut.data.shape[1]
426
433
427 self.dataOut.flagNoData = False
434 self.dataOut.flagNoData = False
428
435
429 self.getBasicHeader()
436 self.getBasicHeader()
430
437
431 self.dataOut.realtime = self.online
438 self.dataOut.realtime = self.online
432
439
433 return self.dataOut.data
440 return self.dataOut.data
434
441
435 class VoltageWriter(JRODataWriter, Operation):
442 class VoltageWriter(JRODataWriter, Operation):
436 """
443 """
437 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
444 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
438 de los datos siempre se realiza por bloques.
445 de los datos siempre se realiza por bloques.
439 """
446 """
440
447
441 ext = ".r"
448 ext = ".r"
442
449
443 optchar = "D"
450 optchar = "D"
444
451
445 shapeBuffer = None
452 shapeBuffer = None
446
453
447
454
448 def __init__(self, **kwargs):
455 def __init__(self, **kwargs):
449 """
456 """
450 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
457 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
451
458
452 Affected:
459 Affected:
453 self.dataOut
460 self.dataOut
454
461
455 Return: None
462 Return: None
456 """
463 """
457 Operation.__init__(self, **kwargs)
464 Operation.__init__(self, **kwargs)
458
465
459 self.nTotalBlocks = 0
466 self.nTotalBlocks = 0
460
467
461 self.profileIndex = 0
468 self.profileIndex = 0
462
469
463 self.isConfig = False
470 self.isConfig = False
464
471
465 self.fp = None
472 self.fp = None
466
473
467 self.flagIsNewFile = 1
474 self.flagIsNewFile = 1
468
475
469 self.blockIndex = 0
476 self.blockIndex = 0
470
477
471 self.flagIsNewBlock = 0
478 self.flagIsNewBlock = 0
472
479
473 self.setFile = None
480 self.setFile = None
474
481
475 self.dtype = None
482 self.dtype = None
476
483
477 self.path = None
484 self.path = None
478
485
479 self.filename = None
486 self.filename = None
480
487
481 self.basicHeaderObj = BasicHeader(LOCALTIME)
488 self.basicHeaderObj = BasicHeader(LOCALTIME)
482
489
483 self.systemHeaderObj = SystemHeader()
490 self.systemHeaderObj = SystemHeader()
484
491
485 self.radarControllerHeaderObj = RadarControllerHeader()
492 self.radarControllerHeaderObj = RadarControllerHeader()
486
493
487 self.processingHeaderObj = ProcessingHeader()
494 self.processingHeaderObj = ProcessingHeader()
488
495
489 def hasAllDataInBuffer(self):
496 def hasAllDataInBuffer(self):
490 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
497 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
491 return 1
498 return 1
492 return 0
499 return 0
493
500
494
501
495 def setBlockDimension(self):
502 def setBlockDimension(self):
496 """
503 """
497 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
504 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
498
505
499 Affected:
506 Affected:
500 self.shape_spc_Buffer
507 self.shape_spc_Buffer
501 self.shape_cspc_Buffer
508 self.shape_cspc_Buffer
502 self.shape_dc_Buffer
509 self.shape_dc_Buffer
503
510
504 Return: None
511 Return: None
505 """
512 """
506 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
513 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
507 self.processingHeaderObj.nHeights,
514 self.processingHeaderObj.nHeights,
508 self.systemHeaderObj.nChannels)
515 self.systemHeaderObj.nChannels)
509
516
510 self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
517 self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
511 self.processingHeaderObj.profilesPerBlock,
518 self.processingHeaderObj.profilesPerBlock,
512 self.processingHeaderObj.nHeights),
519 self.processingHeaderObj.nHeights),
513 dtype=numpy.dtype('complex64'))
520 dtype=numpy.dtype('complex64'))
514
521
515 def writeBlock(self):
522 def writeBlock(self):
516 """
523 """
517 Escribe el buffer en el file designado
524 Escribe el buffer en el file designado
518
525
519 Affected:
526 Affected:
520 self.profileIndex
527 self.profileIndex
521 self.flagIsNewFile
528 self.flagIsNewFile
522 self.flagIsNewBlock
529 self.flagIsNewBlock
523 self.nTotalBlocks
530 self.nTotalBlocks
524 self.blockIndex
531 self.blockIndex
525
532
526 Return: None
533 Return: None
527 """
534 """
528 data = numpy.zeros( self.shapeBuffer, self.dtype )
535 data = numpy.zeros( self.shapeBuffer, self.dtype )
529
536
530 junk = numpy.transpose(self.datablock, (1,2,0))
537 junk = numpy.transpose(self.datablock, (1,2,0))
531
538
532 data['real'] = junk.real
539 data['real'] = junk.real
533 data['imag'] = junk.imag
540 data['imag'] = junk.imag
534
541
535 data = data.reshape( (-1) )
542 data = data.reshape( (-1) )
536
543
537 data.tofile( self.fp )
544 data.tofile( self.fp )
538
545
539 self.datablock.fill(0)
546 self.datablock.fill(0)
540
547
541 self.profileIndex = 0
548 self.profileIndex = 0
542 self.flagIsNewFile = 0
549 self.flagIsNewFile = 0
543 self.flagIsNewBlock = 1
550 self.flagIsNewBlock = 1
544
551
545 self.blockIndex += 1
552 self.blockIndex += 1
546 self.nTotalBlocks += 1
553 self.nTotalBlocks += 1
547
554
548 # print "[Writing] Block = %04d" %self.blockIndex
555 # print "[Writing] Block = %04d" %self.blockIndex
549
556
550 def putData(self):
557 def putData(self):
551 """
558 """
552 Setea un bloque de datos y luego los escribe en un file
559 Setea un bloque de datos y luego los escribe en un file
553
560
554 Affected:
561 Affected:
555 self.flagIsNewBlock
562 self.flagIsNewBlock
556 self.profileIndex
563 self.profileIndex
557
564
558 Return:
565 Return:
559 0 : Si no hay data o no hay mas files que puedan escribirse
566 0 : Si no hay data o no hay mas files que puedan escribirse
560 1 : Si se escribio la data de un bloque en un file
567 1 : Si se escribio la data de un bloque en un file
561 """
568 """
562 if self.dataOut.flagNoData:
569 if self.dataOut.flagNoData:
563 return 0
570 return 0
564
571
565 self.flagIsNewBlock = 0
572 self.flagIsNewBlock = 0
566
573
567 if self.dataOut.flagDiscontinuousBlock:
574 if self.dataOut.flagDiscontinuousBlock:
568 self.datablock.fill(0)
575 self.datablock.fill(0)
569 self.profileIndex = 0
576 self.profileIndex = 0
570 self.setNextFile()
577 self.setNextFile()
571
578
572 if self.profileIndex == 0:
579 if self.profileIndex == 0:
573 self.setBasicHeader()
580 self.setBasicHeader()
574
581
575 self.datablock[:,self.profileIndex,:] = self.dataOut.data
582 self.datablock[:,self.profileIndex,:] = self.dataOut.data
576
583
577 self.profileIndex += 1
584 self.profileIndex += 1
578
585
579 if self.hasAllDataInBuffer():
586 if self.hasAllDataInBuffer():
580 #if self.flagIsNewFile:
587 #if self.flagIsNewFile:
581 self.writeNextBlock()
588 self.writeNextBlock()
582 # self.setFirstHeader()
589 # self.setFirstHeader()
583
590
584 return 1
591 return 1
585
592
586 def __getBlockSize(self):
593 def __getBlockSize(self):
587 '''
594 '''
588 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
595 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
589 '''
596 '''
590
597
591 dtype_width = self.getDtypeWidth()
598 dtype_width = self.getDtypeWidth()
592
599
593 blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.profilesPerBlock * dtype_width * 2)
600 blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.profilesPerBlock * dtype_width * 2)
594
601
595 return blocksize
602 return blocksize
596
603
597 def setFirstHeader(self):
604 def setFirstHeader(self):
598
605
599 """
606 """
600 Obtiene una copia del First Header
607 Obtiene una copia del First Header
601
608
602 Affected:
609 Affected:
603 self.systemHeaderObj
610 self.systemHeaderObj
604 self.radarControllerHeaderObj
611 self.radarControllerHeaderObj
605 self.dtype
612 self.dtype
606
613
607 Return:
614 Return:
608 None
615 None
609 """
616 """
610
617
611 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
618 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
612 self.systemHeaderObj.nChannels = self.dataOut.nChannels
619 self.systemHeaderObj.nChannels = self.dataOut.nChannels
613 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
620 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
614
621
615 self.processingHeaderObj.dtype = 0 # Voltage
622 self.processingHeaderObj.dtype = 0 # Voltage
616 self.processingHeaderObj.blockSize = self.__getBlockSize()
623 self.processingHeaderObj.blockSize = self.__getBlockSize()
617 self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
624 self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
618 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
625 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
619 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
626 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
620 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
627 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
621 self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
628 self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
622 self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
629 self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
623
630
624 if self.dataOut.code is not None:
631 if self.dataOut.code is not None:
625 self.processingHeaderObj.code = self.dataOut.code
632 self.processingHeaderObj.code = self.dataOut.code
626 self.processingHeaderObj.nCode = self.dataOut.nCode
633 self.processingHeaderObj.nCode = self.dataOut.nCode
627 self.processingHeaderObj.nBaud = self.dataOut.nBaud
634 self.processingHeaderObj.nBaud = self.dataOut.nBaud
628
635
629 if self.processingHeaderObj.nWindows != 0:
636 if self.processingHeaderObj.nWindows != 0:
630 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
637 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
631 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
638 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
632 self.processingHeaderObj.nHeights = self.dataOut.nHeights
639 self.processingHeaderObj.nHeights = self.dataOut.nHeights
633 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
640 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
634
641
635 self.processingHeaderObj.processFlags = self.getProcessFlags()
642 self.processingHeaderObj.processFlags = self.getProcessFlags()
636
643
637 self.setBasicHeader()
644 self.setBasicHeader()
General Comments 0
You need to be logged in to leave comments. Login now