| @@ -0,0 +1,60 | |||
|
|
1 | import os, sys | |
|
|
2 | import numpy | |
|
|
3 | ||
|
|
4 | path = os.path.split(os.getcwd())[0] | |
|
|
5 | sys.path.append(path) | |
|
|
6 | ||
|
|
7 | from JROData import JROData | |
|
|
8 | from IO.JROHeader import SystemHeader, RadarControllerHeader | |
|
|
9 | ||
|
|
10 | class Spectra(JROData): | |
|
|
11 | data_spc = None | |
|
|
12 | ||
|
|
13 | data_cspc = None | |
|
|
14 | ||
|
|
15 | data_dc = None | |
|
|
16 | ||
|
|
17 | nFFTPoints = None | |
|
|
18 | ||
|
|
19 | nPairs = None | |
|
|
20 | ||
|
|
21 | pairsList = None | |
|
|
22 | ||
|
|
23 | nIncohInt = None | |
|
|
24 | ||
|
|
25 | def __init__(self): | |
|
|
26 | ''' | |
|
|
27 | Constructor | |
|
|
28 | ''' | |
|
|
29 | ||
|
|
30 | self.m_RadarControllerHeader = RadarControllerHeader() | |
|
|
31 | ||
|
|
32 | self.m_SystemHeader = SystemHeader() | |
|
|
33 | ||
|
|
34 | self.type = "Spectra" | |
|
|
35 | ||
|
|
36 | #data es un numpy array de 2 dmensiones ( canales, alturas) | |
|
|
37 | # self.data = None | |
|
|
38 | ||
|
|
39 | self.dtype = None | |
|
|
40 | ||
|
|
41 | self.nChannels = 0 | |
|
|
42 | ||
|
|
43 | self.nHeights = 0 | |
|
|
44 | ||
|
|
45 | self.nProfiles = None | |
|
|
46 | ||
|
|
47 | self.heightList = None | |
|
|
48 | ||
|
|
49 | self.channelList = None | |
|
|
50 | ||
|
|
51 | self.channelIndexList = None | |
|
|
52 | ||
|
|
53 | self.flagNoData = True | |
|
|
54 | ||
|
|
55 | self.flagTimeBlock = False | |
|
|
56 | ||
|
|
57 | self.dataUtcTime = None | |
|
|
58 | ||
|
|
59 | self.nIncohInt = None | |
|
|
60 | No newline at end of file | |
| This diff has been collapsed as it changes many lines, (539 lines changed) Show them Hide them | |||
| @@ -0,0 +1,539 | |||
|
|
1 | ''' | |
|
|
2 | File: SpectraIO.py | |
|
|
3 | Created on 20/02/2012 | |
|
|
4 | ||
|
|
5 | @author $Author: dsuarez $ | |
|
|
6 | @version $Id: SpectraIO.py 110 2012-07-19 15:18:18Z dsuarez $ | |
|
|
7 | ''' | |
|
|
8 | ||
|
|
9 | import os, sys | |
|
|
10 | import numpy | |
|
|
11 | import glob | |
|
|
12 | import fnmatch | |
|
|
13 | import time, datetime | |
|
|
14 | ||
|
|
15 | path = os.path.split(os.getcwd())[0] | |
|
|
16 | sys.path.append(path) | |
|
|
17 | ||
|
|
18 | from Model.JROHeader import * | |
|
|
19 | from Model.Spectra import Spectra | |
|
|
20 | ||
|
|
21 | from JRODataIO import JRODataReader | |
|
|
22 | from JRODataIO import JRODataWriter | |
|
|
23 | from JRODataIO import isNumber | |
|
|
24 | ||
|
|
25 | ||
|
|
26 | class SpectraReader(JRODataReader): | |
|
|
27 | """ | |
|
|
28 | Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura | |
|
|
29 | de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones) | |
|
|
30 | son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel. | |
|
|
31 | ||
|
|
32 | paresCanalesIguales * alturas * perfiles (Self Spectra) | |
|
|
33 | paresCanalesDiferentes * alturas * perfiles (Cross Spectra) | |
|
|
34 | canales * alturas (DC Channels) | |
|
|
35 | ||
|
|
36 | Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader, | |
|
|
37 | RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la | |
|
|
38 | cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de | |
|
|
39 | datos desde el "buffer" cada vez que se ejecute el metodo "getData". | |
|
|
40 | ||
|
|
41 | Example: | |
|
|
42 | dpath = "/home/myuser/data" | |
|
|
43 | ||
|
|
44 | startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0) | |
|
|
45 | ||
|
|
46 | endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0) | |
|
|
47 | ||
|
|
48 | readerObj = SpectraReader() | |
|
|
49 | ||
|
|
50 | readerObj.setup(dpath, startTime, endTime) | |
|
|
51 | ||
|
|
52 | while(True): | |
|
|
53 | ||
|
|
54 | readerObj.getData() | |
|
|
55 | ||
|
|
56 | print readerObj.dataOutObj.data | |
|
|
57 | ||
|
|
58 | if readerObj.flagNoMoreFiles: | |
|
|
59 | break | |
|
|
60 | ||
|
|
61 | """ | |
|
|
62 | dataOutObj = None | |
|
|
63 | ||
|
|
64 | datablock = None | |
|
|
65 | ||
|
|
66 | pts2read_SelfSpectra = 0 | |
|
|
67 | ||
|
|
68 | pts2read_CrossSpectra = 0 | |
|
|
69 | ||
|
|
70 | pts2read_DCchannels = 0 | |
|
|
71 | ||
|
|
72 | ext = ".pdata" | |
|
|
73 | ||
|
|
74 | optchar = "P" | |
|
|
75 | ||
|
|
76 | flag_cspc = False | |
|
|
77 | ||
|
|
78 | def __init__(self, dataOutObj=None): | |
|
|
79 | """ | |
|
|
80 | Inicializador de la clase SpectraReader para la lectura de datos de espectros. | |
|
|
81 | ||
|
|
82 | Inputs: | |
|
|
83 | dataOutObj : Objeto de la clase Spectra. Este objeto sera utilizado para | |
|
|
84 | almacenar un perfil de datos cada vez que se haga un requerimiento | |
|
|
85 | (getData). El perfil sera obtenido a partir del buffer de datos, | |
|
|
86 | si el buffer esta vacio se hara un nuevo proceso de lectura de un | |
|
|
87 | bloque de datos. | |
|
|
88 | Si este parametro no es pasado se creara uno internamente. | |
|
|
89 | ||
|
|
90 | Affected: | |
|
|
91 | self.dataOutObj | |
|
|
92 | ||
|
|
93 | Return : None | |
|
|
94 | """ | |
|
|
95 | ||
|
|
96 | self.pts2read_SelfSpectra = 0 | |
|
|
97 | ||
|
|
98 | self.pts2read_CrossSpectra = 0 | |
|
|
99 | ||
|
|
100 | self.pts2read_DCs = 0 | |
|
|
101 | ||
|
|
102 | self.datablock = None | |
|
|
103 | ||
|
|
104 | self.utc = None | |
|
|
105 | ||
|
|
106 | self.ext = ".pdata" | |
|
|
107 | ||
|
|
108 | self.optchar = "P" | |
|
|
109 | ||
|
|
110 | self.basicHeaderObj = BasicHeader() | |
|
|
111 | ||
|
|
112 | self.systemHeaderObj = SystemHeader() | |
|
|
113 | ||
|
|
114 | self.radarControllerHeaderObj = RadarControllerHeader() | |
|
|
115 | ||
|
|
116 | self.processingHeaderObj = ProcessingHeader() | |
|
|
117 | ||
|
|
118 | self.online = 0 | |
|
|
119 | ||
|
|
120 | self.fp = None | |
|
|
121 | ||
|
|
122 | self.idFile = None | |
|
|
123 | ||
|
|
124 | self.dtype = None | |
|
|
125 | ||
|
|
126 | self.fileSizeByHeader = None | |
|
|
127 | ||
|
|
128 | self.filenameList = [] | |
|
|
129 | ||
|
|
130 | self.filename = None | |
|
|
131 | ||
|
|
132 | self.fileSize = None | |
|
|
133 | ||
|
|
134 | self.firstHeaderSize = 0 | |
|
|
135 | ||
|
|
136 | self.basicHeaderSize = 24 | |
|
|
137 | ||
|
|
138 | self.pathList = [] | |
|
|
139 | ||
|
|
140 | self.lastUTTime = 0 | |
|
|
141 | ||
|
|
142 | self.maxTimeStep = 30 | |
|
|
143 | ||
|
|
144 | self.flagNoMoreFiles = 0 | |
|
|
145 | ||
|
|
146 | self.set = 0 | |
|
|
147 | ||
|
|
148 | self.path = None | |
|
|
149 | ||
|
|
150 | self.delay = 3 #seconds | |
|
|
151 | ||
|
|
152 | self.nTries = 3 #quantity tries | |
|
|
153 | ||
|
|
154 | self.nFiles = 3 #number of files for searching | |
|
|
155 | ||
|
|
156 | self.nReadBlocks = 0 | |
|
|
157 | ||
|
|
158 | self.flagIsNewFile = 1 | |
|
|
159 | ||
|
|
160 | self.ippSeconds = 0 | |
|
|
161 | ||
|
|
162 | self.flagTimeBlock = 0 | |
|
|
163 | ||
|
|
164 | self.flagIsNewBlock = 0 | |
|
|
165 | ||
|
|
166 | self.nTotalBlocks = 0 | |
|
|
167 | ||
|
|
168 | self.blocksize = 0 | |
|
|
169 | ||
|
|
170 | ||
|
|
171 | def createObjByDefault(self): | |
|
|
172 | ||
|
|
173 | dataObj = Spectra() | |
|
|
174 | ||
|
|
175 | return dataObj | |
|
|
176 | ||
|
|
177 | def __hasNotDataInBuffer(self): | |
|
|
178 | return 1 | |
|
|
179 | ||
|
|
180 | ||
|
|
181 | def getBlockDimension(self): | |
|
|
182 | """ | |
|
|
183 | Obtiene la cantidad de puntos a leer por cada bloque de datos | |
|
|
184 | ||
|
|
185 | Affected: | |
|
|
186 | self.nChannels | |
|
|
187 | self.nPairs | |
|
|
188 | self.pts2read_SelfSpectra | |
|
|
189 | self.pts2read_CrossSpectra | |
|
|
190 | self.pts2read_DCchannels | |
|
|
191 | self.blocksize | |
|
|
192 | self.dataOutObj.nChannels | |
|
|
193 | self.dataOutObj.nPairs | |
|
|
194 | ||
|
|
195 | Return: | |
|
|
196 | None | |
|
|
197 | """ | |
|
|
198 | self.nChannels = 0 | |
|
|
199 | self.nPairs = 0 | |
|
|
200 | self.pairList = [] | |
|
|
201 | ||
|
|
202 | for i in range( 0, self.processingHeaderObj.totalSpectra*2, 2 ): | |
|
|
203 | if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]: | |
|
|
204 | self.nChannels = self.nChannels + 1 #par de canales iguales | |
|
|
205 | else: | |
|
|
206 | self.nPairs = self.nPairs + 1 #par de canales diferentes | |
|
|
207 | self.pairList.append( (self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]) ) | |
|
|
208 | ||
|
|
209 | pts2read = self.processingHeaderObj.numHeights * self.processingHeaderObj.profilesPerBlock | |
|
|
210 | ||
|
|
211 | self.pts2read_SelfSpectra = int(self.nChannels * pts2read) | |
|
|
212 | self.blocksize = self.pts2read_SelfSpectra | |
|
|
213 | ||
|
|
214 | if self.processingHeaderObj.flag_cspc: | |
|
|
215 | self.pts2read_CrossSpectra = int(self.nPairs * pts2read) | |
|
|
216 | self.blocksize += self.pts2read_CrossSpectra | |
|
|
217 | ||
|
|
218 | if self.processingHeaderObj.flag_dc: | |
|
|
219 | self.pts2read_DCchannels = int(self.systemHeaderObj.numChannels * self.processingHeaderObj.numHeights) | |
|
|
220 | self.blocksize += self.pts2read_DCchannels | |
|
|
221 | ||
|
|
222 | # self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels | |
|
|
223 | ||
|
|
224 | ||
|
|
225 | def readBlock(self): | |
|
|
226 | """ | |
|
|
227 | Lee el bloque de datos desde la posicion actual del puntero del archivo | |
|
|
228 | (self.fp) y actualiza todos los parametros relacionados al bloque de datos | |
|
|
229 | (metadata + data). La data leida es almacenada en el buffer y el contador del buffer | |
|
|
230 | es seteado a 0 | |
|
|
231 | ||
|
|
232 | Return: None | |
|
|
233 | ||
|
|
234 | Variables afectadas: | |
|
|
235 | self.datablockIndex | |
|
|
236 | self.flagIsNewFile | |
|
|
237 | self.flagIsNewBlock | |
|
|
238 | self.nTotalBlocks | |
|
|
239 | self.data_spc | |
|
|
240 | self.data_cspc | |
|
|
241 | self.data_dc | |
|
|
242 | ||
|
|
243 | Exceptions: | |
|
|
244 | Si un bloque leido no es un bloque valido | |
|
|
245 | """ | |
|
|
246 | blockOk_flag = False | |
|
|
247 | fpointer = self.fp.tell() | |
|
|
248 | ||
|
|
249 | spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra ) | |
|
|
250 | spc = spc.reshape( (self.nChannels, self.processingHeaderObj.numHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D | |
|
|
251 | ||
|
|
252 | if self.flag_cspc: | |
|
|
253 | cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra ) | |
|
|
254 | cspc = cspc.reshape( (self.nPairs, self.processingHeaderObj.numHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D | |
|
|
255 | ||
|
|
256 | if self.processingHeaderObj.flag_dc: | |
|
|
257 | dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.processingHeaderObj.numHeights*self.systemHeaderObj.numChannels) ) | |
|
|
258 | dc = dc.reshape( (self.systemHeaderObj.numChannels, self.processingHeaderObj.numHeights) ) #transforma a un arreglo 2D | |
|
|
259 | ||
|
|
260 | ||
|
|
261 | if not(self.processingHeaderObj.shif_fft): | |
|
|
262 | spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones | |
|
|
263 | ||
|
|
264 | if self.flag_cspc: | |
|
|
265 | cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones | |
|
|
266 | ||
|
|
267 | ||
|
|
268 | spc = numpy.transpose( spc, (0,2,1) ) | |
|
|
269 | self.data_spc = spc | |
|
|
270 | ||
|
|
271 | if self.flag_cspc: | |
|
|
272 | cspc = numpy.transpose( cspc, (0,2,1) ) | |
|
|
273 | self.data_cspc = cspc['real'] + cspc['imag']*1j | |
|
|
274 | else: | |
|
|
275 | self.data_cspc = None | |
|
|
276 | ||
|
|
277 | if self.processingHeaderObj.flag_dc: | |
|
|
278 | self.data_dc = dc['real'] + dc['imag']*1j | |
|
|
279 | else: | |
|
|
280 | self.data_dc = None | |
|
|
281 | ||
|
|
282 | self.datablockIndex = 0 | |
|
|
283 | self.flagIsNewFile = 0 | |
|
|
284 | self.flagIsNewBlock = 1 | |
|
|
285 | ||
|
|
286 | self.nTotalBlocks += 1 | |
|
|
287 | self.nReadBlocks += 1 | |
|
|
288 | ||
|
|
289 | return 1 | |
|
|
290 | ||
|
|
291 | ||
|
|
292 | def getData(self): | |
|
|
293 | """ | |
|
|
294 | Copia el buffer de lectura a la clase "Spectra", | |
|
|
295 | con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de | |
|
|
296 | lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock" | |
|
|
297 | ||
|
|
298 | Return: | |
|
|
299 | 0 : Si no hay mas archivos disponibles | |
|
|
300 | 1 : Si hizo una buena copia del buffer | |
|
|
301 | ||
|
|
302 | Affected: | |
|
|
303 | self.dataOutObj | |
|
|
304 | self.datablockIndex | |
|
|
305 | self.flagTimeBlock | |
|
|
306 | self.flagIsNewBlock | |
|
|
307 | """ | |
|
|
308 | ||
|
|
309 | if self.flagNoMoreFiles: return 0 | |
|
|
310 | ||
|
|
311 | self.flagTimeBlock = 0 | |
|
|
312 | self.flagIsNewBlock = 0 | |
|
|
313 | ||
|
|
314 | if self.__hasNotDataInBuffer(): | |
|
|
315 | ||
|
|
316 | if not( self.readNextBlock() ): | |
|
|
317 | return 0 | |
|
|
318 | ||
|
|
319 | self.updateDataHeader() | |
|
|
320 | ||
|
|
321 | if self.flagNoMoreFiles == 1: | |
|
|
322 | print 'Process finished' | |
|
|
323 | return 0 | |
|
|
324 | ||
|
|
325 | #data es un numpy array de 3 dmensiones (perfiles, alturas y canales) | |
|
|
326 | ||
|
|
327 | if self.data_dc == None: | |
|
|
328 | self.dataOutObj.flagNoData = True | |
|
|
329 | return 0 | |
|
|
330 | ||
|
|
331 | self.dataOutObj.flagNoData = False | |
|
|
332 | self.dataOutObj.flagTimeBlock = self.flagTimeBlock | |
|
|
333 | ||
|
|
334 | self.dataOutObj.data_spc = self.data_spc | |
|
|
335 | self.dataOutObj.data_cspc = self.data_cspc | |
|
|
336 | self.dataOutObj.data_dc = self.data_dc | |
|
|
337 | ||
|
|
338 | return 1 | |
|
|
339 | ||
|
|
340 | ||
|
|
341 | class SpectraWriter(JRODataWriter): | |
|
|
342 | ||
|
|
343 | """ | |
|
|
344 | Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura | |
|
|
345 | de los datos siempre se realiza por bloques. | |
|
|
346 | """ | |
|
|
347 | ||
|
|
348 | dataOutObj = None | |
|
|
349 | ||
|
|
350 | shape_spc_Buffer = None | |
|
|
351 | shape_cspc_Buffer = None | |
|
|
352 | shape_dc_Buffer = None | |
|
|
353 | ||
|
|
354 | data_spc = None | |
|
|
355 | data_cspc = None | |
|
|
356 | data_dc = None | |
|
|
357 | ||
|
|
358 | ||
|
|
359 | def __init__(self, dataOutObj=None): | |
|
|
360 | """ | |
|
|
361 | Inicializador de la clase SpectraWriter para la escritura de datos de espectros. | |
|
|
362 | ||
|
|
363 | Affected: | |
|
|
364 | self.dataOutObj | |
|
|
365 | self.basicHeaderObj | |
|
|
366 | self.systemHeaderObj | |
|
|
367 | self.radarControllerHeaderObj | |
|
|
368 | self.processingHeaderObj | |
|
|
369 | ||
|
|
370 | Return: None | |
|
|
371 | """ | |
|
|
372 | if dataOutObj == None: | |
|
|
373 | dataOutObj = Spectra() | |
|
|
374 | ||
|
|
375 | if not( isinstance(dataOutObj, Spectra) ): | |
|
|
376 | raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object" | |
|
|
377 | ||
|
|
378 | self.dataOutObj = dataOutObj | |
|
|
379 | ||
|
|
380 | self.ext = ".pdata" | |
|
|
381 | ||
|
|
382 | self.optchar = "P" | |
|
|
383 | ||
|
|
384 | self.shape_spc_Buffer = None | |
|
|
385 | self.shape_cspc_Buffer = None | |
|
|
386 | self.shape_dc_Buffer = None | |
|
|
387 | ||
|
|
388 | self.data_spc = None | |
|
|
389 | self.data_cspc = None | |
|
|
390 | self.data_dc = None | |
|
|
391 | ||
|
|
392 | #################################### | |
|
|
393 | ||
|
|
394 | self.fp = None | |
|
|
395 | ||
|
|
396 | self.nWriteBlocks = 0 | |
|
|
397 | ||
|
|
398 | self.flagIsNewFile = 1 | |
|
|
399 | ||
|
|
400 | self.nTotalBlocks = 0 | |
|
|
401 | ||
|
|
402 | self.flagIsNewBlock = 0 | |
|
|
403 | ||
|
|
404 | self.flagNoMoreFiles = 0 | |
|
|
405 | ||
|
|
406 | self.setFile = None | |
|
|
407 | ||
|
|
408 | self.dataType = None | |
|
|
409 | ||
|
|
410 | self.path = None | |
|
|
411 | ||
|
|
412 | self.noMoreFiles = 0 | |
|
|
413 | ||
|
|
414 | self.filename = None | |
|
|
415 | ||
|
|
416 | self.basicHeaderObj = BasicHeader() | |
|
|
417 | ||
|
|
418 | self.systemHeaderObj = SystemHeader() | |
|
|
419 | ||
|
|
420 | self.radarControllerHeaderObj = RadarControllerHeader() | |
|
|
421 | ||
|
|
422 | self.processingHeaderObj = ProcessingHeader() | |
|
|
423 | ||
|
|
424 | ||
|
|
425 | def hasAllDataInBuffer(self): | |
|
|
426 | return 1 | |
|
|
427 | ||
|
|
428 | ||
|
|
429 | def setBlockDimension(self): | |
|
|
430 | """ | |
|
|
431 | Obtiene las formas dimensionales del los subbloques de datos que componen un bloque | |
|
|
432 | ||
|
|
433 | Affected: | |
|
|
434 | self.shape_spc_Buffer | |
|
|
435 | self.shape_cspc_Buffer | |
|
|
436 | self.shape_dc_Buffer | |
|
|
437 | ||
|
|
438 | Return: None | |
|
|
439 | """ | |
|
|
440 | self.shape_spc_Buffer = (self.dataOutObj.nChannels, | |
|
|
441 | self.processingHeaderObj.numHeights, | |
|
|
442 | self.processingHeaderObj.profilesPerBlock) | |
|
|
443 | ||
|
|
444 | self.shape_cspc_Buffer = (self.dataOutObj.nPairs, | |
|
|
445 | self.processingHeaderObj.numHeights, | |
|
|
446 | self.processingHeaderObj.profilesPerBlock) | |
|
|
447 | ||
|
|
448 | self.shape_dc_Buffer = (self.systemHeaderObj.numChannels, | |
|
|
449 | self.processingHeaderObj.numHeights) | |
|
|
450 | ||
|
|
451 | ||
|
|
452 | def writeBlock(self): | |
|
|
453 | """ | |
|
|
454 | Escribe el buffer en el file designado | |
|
|
455 | ||
|
|
456 | Affected: | |
|
|
457 | self.data_spc | |
|
|
458 | self.data_cspc | |
|
|
459 | self.data_dc | |
|
|
460 | self.flagIsNewFile | |
|
|
461 | self.flagIsNewBlock | |
|
|
462 | self.nTotalBlocks | |
|
|
463 | self.nWriteBlocks | |
|
|
464 | ||
|
|
465 | Return: None | |
|
|
466 | """ | |
|
|
467 | ||
|
|
468 | spc = numpy.transpose( self.data_spc, (0,2,1) ) | |
|
|
469 | if not( self.processingHeaderObj.shif_fft ): | |
|
|
470 | spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones | |
|
|
471 | data = spc.reshape((-1)) | |
|
|
472 | data.tofile(self.fp) | |
|
|
473 | ||
|
|
474 | if self.data_cspc != None: | |
|
|
475 | data = numpy.zeros( self.shape_cspc_Buffer, self.dataType ) | |
|
|
476 | cspc = numpy.transpose( self.data_cspc, (0,2,1) ) | |
|
|
477 | if not( self.processingHeaderObj.shif_fft ): | |
|
|
478 | cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones | |
|
|
479 | data['real'] = cspc.real | |
|
|
480 | data['imag'] = cspc.imag | |
|
|
481 | data = data.reshape((-1)) | |
|
|
482 | data.tofile(self.fp) | |
|
|
483 | ||
|
|
484 | data = numpy.zeros( self.shape_dc_Buffer, self.dataType ) | |
|
|
485 | dc = self.data_dc | |
|
|
486 | data['real'] = dc.real | |
|
|
487 | data['imag'] = dc.imag | |
|
|
488 | data = data.reshape((-1)) | |
|
|
489 | data.tofile(self.fp) | |
|
|
490 | ||
|
|
491 | self.data_spc.fill(0) | |
|
|
492 | self.data_dc.fill(0) | |
|
|
493 | if self.data_cspc != None: | |
|
|
494 | self.data_cspc.fill(0) | |
|
|
495 | ||
|
|
496 | self.flagIsNewFile = 0 | |
|
|
497 | self.flagIsNewBlock = 1 | |
|
|
498 | self.nTotalBlocks += 1 | |
|
|
499 | self.nWriteBlocks += 1 | |
|
|
500 | ||
|
|
501 | ||
|
|
502 | def putData(self): | |
|
|
503 | """ | |
|
|
504 | Setea un bloque de datos y luego los escribe en un file | |
|
|
505 | ||
|
|
506 | Affected: | |
|
|
507 | self.data_spc | |
|
|
508 | self.data_cspc | |
|
|
509 | self.data_dc | |
|
|
510 | ||
|
|
511 | Return: | |
|
|
512 | 0 : Si no hay data o no hay mas files que puedan escribirse | |
|
|
513 | 1 : Si se escribio la data de un bloque en un file | |
|
|
514 | """ | |
|
|
515 | self.flagIsNewBlock = 0 | |
|
|
516 | ||
|
|
517 | if self.dataOutObj.flagNoData: | |
|
|
518 | return 0 | |
|
|
519 | ||
|
|
520 | if self.dataOutObj.flagTimeBlock: | |
|
|
521 | self.data_spc.fill(0) | |
|
|
522 | self.data_cspc.fill(0) | |
|
|
523 | self.data_dc.fill(0) | |
|
|
524 | self.setNextFile() | |
|
|
525 | ||
|
|
526 | self.data_spc = self.dataOutObj.data_spc | |
|
|
527 | self.data_cspc = self.dataOutObj.data_cspc | |
|
|
528 | self.data_dc = self.dataOutObj.data_dc | |
|
|
529 | ||
|
|
530 | # #self.processingHeaderObj.dataBlocksPerFile) | |
|
|
531 | if self.hasAllDataInBuffer(): | |
|
|
532 | self.getDataHeader() | |
|
|
533 | self.writeNextBlock() | |
|
|
534 | ||
|
|
535 | if self.flagNoMoreFiles: | |
|
|
536 | #print 'Process finished' | |
|
|
537 | return 0 | |
|
|
538 | ||
|
|
539 | return 1 No newline at end of file | |
| @@ -1,52 +1,48 | |||
|
|
1 | 1 | import os, sys |
|
|
2 | 2 | import numpy |
|
|
3 | 3 | |
|
|
4 | 4 | path = os.path.split(os.getcwd())[0] |
|
|
5 | 5 | sys.path.append(path) |
|
|
6 | 6 | |
|
|
7 | 7 | from JROData import JROData |
|
|
8 | 8 | from IO.JROHeader import SystemHeader, RadarControllerHeader |
|
|
9 | 9 | |
|
|
10 | 10 | class Voltage(JROData): |
|
|
11 | 11 | |
|
|
12 | 12 | nCohInt = None |
|
|
13 | 13 | |
|
|
14 | 14 | def __init__(self): |
|
|
15 | 15 | ''' |
|
|
16 | 16 | Constructor |
|
|
17 | 17 | ''' |
|
|
18 | 18 | |
|
|
19 | 19 | self.m_RadarControllerHeader = RadarControllerHeader() |
|
|
20 | 20 | |
|
|
21 | 21 | self.m_SystemHeader = SystemHeader() |
|
|
22 | 22 | |
|
|
23 | 23 | self.type = "Voltage" |
|
|
24 | 24 | |
|
|
25 | 25 | #data es un numpy array de 2 dmensiones ( canales, alturas) |
|
|
26 | 26 | self.data = None |
|
|
27 | 27 | |
|
|
28 | 28 | self.dtype = None |
|
|
29 | 29 | |
|
|
30 | 30 | self.nChannels = 0 |
|
|
31 | 31 | |
|
|
32 | 32 | self.nHeights = 0 |
|
|
33 | 33 | |
|
|
34 | 34 | self.nProfiles = None |
|
|
35 | 35 | |
|
|
36 | 36 | self.heightList = None |
|
|
37 | 37 | |
|
|
38 | 38 | self.channelList = None |
|
|
39 | 39 | |
|
|
40 | 40 | self.channelIndexList = None |
|
|
41 | 41 | |
|
|
42 | 42 | self.flagNoData = True |
|
|
43 | 43 | |
|
|
44 | 44 | self.flagTimeBlock = False |
|
|
45 | 45 | |
|
|
46 | 46 | self.dataUtcTime = None |
|
|
47 | 47 | |
|
|
48 | 48 | self.nCohInt = None |
|
|
49 | ||
|
|
50 | ||
|
|
51 | ||
|
|
52 | No newline at end of file | |
| @@ -1,667 +1,727 | |||
|
|
1 | 1 | import os, sys |
|
|
2 | 2 | import glob |
|
|
3 | 3 | import time |
|
|
4 | 4 | import numpy |
|
|
5 | 5 | import fnmatch |
|
|
6 | 6 | import time, datetime |
|
|
7 | 7 | |
|
|
8 | 8 | path = os.path.split(os.getcwd())[0] |
|
|
9 | 9 | sys.path.append(path) |
|
|
10 | 10 | |
|
|
11 | 11 | from JROHeader import * |
|
|
12 | 12 | from Data.JROData import JROData |
|
|
13 | 13 | |
|
|
14 | def isNumber(str): | |
|
|
15 | """ | |
|
|
16 | Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero. | |
|
|
17 | ||
|
|
18 | Excepciones: | |
|
|
19 | Si un determinado string no puede ser convertido a numero | |
|
|
20 | Input: | |
|
|
21 | str, string al cual se le analiza para determinar si convertible a un numero o no | |
|
|
22 | ||
|
|
23 | Return: | |
|
|
24 | True : si el string es uno numerico | |
|
|
25 | False : no es un string numerico | |
|
|
26 | """ | |
|
|
27 | try: | |
|
|
28 | float( str ) | |
|
|
29 | return True | |
|
|
30 | except: | |
|
|
31 | return False | |
|
|
32 | ||
|
|
14 | 33 | def isThisFileinRange(filename, startUTSeconds, endUTSeconds): |
|
|
15 | 34 | """ |
|
|
16 | 35 | Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado. |
|
|
17 | 36 | |
|
|
18 | 37 | Inputs: |
|
|
19 | 38 | filename : nombre completo del archivo de datos en formato Jicamarca (.r) |
|
|
20 | 39 | |
|
|
21 | 40 | startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en |
|
|
22 | 41 | segundos contados desde 01/01/1970. |
|
|
23 | 42 | endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en |
|
|
24 | 43 | segundos contados desde 01/01/1970. |
|
|
25 | 44 | |
|
|
26 | 45 | Return: |
|
|
27 | 46 | Boolean : Retorna True si el archivo de datos contiene datos en el rango de |
|
|
28 | 47 | fecha especificado, de lo contrario retorna False. |
|
|
29 | 48 | |
|
|
30 | 49 | Excepciones: |
|
|
31 | 50 | Si el archivo no existe o no puede ser abierto |
|
|
32 | 51 | Si la cabecera no puede ser leida. |
|
|
33 | 52 | |
|
|
34 | 53 | """ |
|
|
35 | 54 | basicHeaderObj = BasicHeader() |
|
|
36 | 55 | |
|
|
37 | 56 | try: |
|
|
38 | 57 | fp = open(filename,'rb') |
|
|
39 | 58 | except: |
|
|
40 | 59 | raise IOError, "The file %s can't be opened" %(filename) |
|
|
41 | 60 | |
|
|
42 | 61 | sts = basicHeaderObj.read(fp) |
|
|
43 | 62 | fp.close() |
|
|
44 | 63 | |
|
|
45 | 64 | if not(sts): |
|
|
46 | 65 | print "Skipping the file %s because it has not a valid header" %(filename) |
|
|
47 | 66 | return 0 |
|
|
48 | 67 | |
|
|
49 | 68 | if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)): |
|
|
50 | 69 | return 0 |
|
|
51 | 70 | |
|
|
52 | 71 | return 1 |
|
|
53 | 72 | |
|
|
54 | 73 | |
|
|
55 | 74 | |
|
|
56 | 75 | |
|
|
57 | 76 | class JRODataIO: |
|
|
58 | 77 | |
|
|
59 | 78 | c = 3E8 |
|
|
60 | 79 | |
|
|
61 | 80 | basicHeaderObj = BasicHeader() |
|
|
62 | 81 | |
|
|
63 | 82 | systemHeaderObj = SystemHeader() |
|
|
64 | 83 | |
|
|
65 | 84 | radarControllerHeaderObj = RadarControllerHeader() |
|
|
66 | 85 | |
|
|
67 | 86 | processingHeaderObj = ProcessingHeader() |
|
|
68 | 87 | |
|
|
69 | 88 | online = 0 |
|
|
70 | 89 | |
|
|
71 | 90 | dtype = None |
|
|
72 | 91 | |
|
|
73 | 92 | pathList = [] |
|
|
74 | 93 | |
|
|
75 | 94 | filenameList = [] |
|
|
76 | 95 | |
|
|
77 | 96 | filename = None |
|
|
78 | 97 | |
|
|
79 | 98 | ext = None |
|
|
80 | 99 | |
|
|
81 | 100 | flagNoMoreFiles = 0 |
|
|
82 | 101 | |
|
|
83 | 102 | flagIsNewFile = 1 |
|
|
84 | 103 | |
|
|
85 | 104 | flagTimeBlock = 0 |
|
|
86 | 105 | |
|
|
87 | 106 | flagIsNewBlock = 0 |
|
|
88 | 107 | |
|
|
89 | 108 | fp = None |
|
|
90 | 109 | |
|
|
91 | 110 | firstHeaderSize = 0 |
|
|
92 | 111 | |
|
|
93 | 112 | basicHeaderSize = 24 |
|
|
94 | 113 | |
|
|
95 | 114 | versionFile = 1103 |
|
|
96 | 115 | |
|
|
97 | 116 | fileSize = None |
|
|
98 | 117 | |
|
|
99 | 118 | ippSeconds = None |
|
|
100 | 119 | |
|
|
101 | 120 | fileSizeByHeader = None |
|
|
102 | 121 | |
|
|
103 | 122 | fileIndex = None |
|
|
104 | 123 | |
|
|
105 | 124 | profileIndex = None |
|
|
106 | 125 | |
|
|
107 | 126 | blockIndex = None |
|
|
108 | 127 | |
|
|
109 | 128 | nTotalBlocks = None |
|
|
110 | 129 | |
|
|
130 | maxTimeStep = 30 | |
|
|
131 | ||
|
|
132 | lastUTTime = None | |
|
|
133 | ||
|
|
111 | 134 | def __init__(self): |
|
|
112 | 135 | pass |
|
|
113 | 136 | |
|
|
114 | 137 | class JRODataReader(JRODataIO): |
|
|
115 | 138 | def __init__(self): |
|
|
116 | 139 | pass |
|
|
117 | 140 | |
|
|
118 | 141 | def createObjByDefault(self): |
|
|
119 | 142 | """ |
|
|
120 | 143 | |
|
|
121 | 144 | """ |
|
|
122 | 145 | raise ValueError, "This method has not been implemented" |
|
|
123 | 146 | |
|
|
124 | 147 | def getBlockDimension(self): |
|
|
125 | 148 | |
|
|
126 | 149 | raise ValueError, "No implemented" |
|
|
127 | 150 | |
|
|
128 | 151 | def __searchFilesOffLine(self, |
|
|
129 | 152 | path, |
|
|
130 | 153 | startDate, |
|
|
131 | 154 | endDate, |
|
|
132 | 155 | startTime=datetime.time(0,0,0), |
|
|
133 | 156 | endTime=datetime.time(23,59,59), |
|
|
134 | 157 | set=None, |
|
|
135 | 158 | expLabel="", |
|
|
136 | 159 | ext=".r"): |
|
|
137 | 160 | dirList = [] |
|
|
138 | 161 | for thisPath in os.listdir(path): |
|
|
139 | 162 | if os.path.isdir(os.path.join(path,thisPath)): |
|
|
140 | 163 | dirList.append(thisPath) |
|
|
141 | 164 | |
|
|
142 | 165 | if not(dirList): |
|
|
143 | 166 | return None, None |
|
|
144 | 167 | |
|
|
145 | 168 | pathList = [] |
|
|
146 | 169 | dateList = [] |
|
|
147 | 170 | |
|
|
148 | 171 | thisDate = startDate |
|
|
149 | 172 | |
|
|
150 | 173 | while(thisDate <= endDate): |
|
|
151 | 174 | year = thisDate.timetuple().tm_year |
|
|
152 | 175 | doy = thisDate.timetuple().tm_yday |
|
|
153 | 176 | |
|
|
154 | 177 | match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy)) |
|
|
155 | 178 | if len(match) == 0: |
|
|
156 | 179 | thisDate += datetime.timedelta(1) |
|
|
157 | 180 | continue |
|
|
158 | 181 | |
|
|
159 | 182 | pathList.append(os.path.join(path,match[0],expLabel)) |
|
|
160 | 183 | dateList.append(thisDate) |
|
|
161 | 184 | thisDate += datetime.timedelta(1) |
|
|
162 | 185 | |
|
|
163 | 186 | filenameList = [] |
|
|
164 | 187 | for index in range(len(pathList)): |
|
|
165 | 188 | |
|
|
166 | 189 | thisPath = pathList[index] |
|
|
167 | 190 | fileList = glob.glob1(thisPath, "*%s" %ext) |
|
|
168 | 191 | fileList.sort() |
|
|
169 | 192 | |
|
|
170 | 193 | #Busqueda de datos en el rango de horas indicados |
|
|
171 | 194 | thisDate = dateList[index] |
|
|
172 | 195 | startDT = datetime.datetime.combine(thisDate, startTime) |
|
|
173 | 196 | endDT = datetime.datetime.combine(thisDate, endTime) |
|
|
174 | 197 | |
|
|
175 | 198 | startUtSeconds = time.mktime(startDT.timetuple()) |
|
|
176 | 199 | endUtSeconds = time.mktime(endDT.timetuple()) |
|
|
177 | 200 | |
|
|
178 | 201 | for file in fileList: |
|
|
179 | 202 | |
|
|
180 | 203 | filename = os.path.join(thisPath,file) |
|
|
181 | 204 | |
|
|
182 | 205 | if isThisFileinRange(filename, startUtSeconds, endUtSeconds): |
|
|
183 | 206 | filenameList.append(filename) |
|
|
184 | 207 | |
|
|
185 | 208 | if not(filenameList): |
|
|
186 | 209 | return None, None |
|
|
187 | 210 | |
|
|
188 | 211 | self.filenameList = filenameList |
|
|
189 | 212 | |
|
|
190 | 213 | return pathList, filenameList |
|
|
191 | 214 | |
|
|
192 | 215 | def setup(self,dataOutObj=None, |
|
|
193 | 216 | path=None,startDate=None, |
|
|
194 | 217 | endDate=None, |
|
|
195 | 218 | startTime=datetime.time(0,0,0), |
|
|
196 | 219 | endTime=datetime.time(23,59,59), |
|
|
197 | 220 | set=0, |
|
|
198 | 221 | expLabel = "", |
|
|
199 | 222 | ext = None, |
|
|
200 | 223 | online = 0): |
|
|
201 | 224 | |
|
|
202 | 225 | if path == None: |
|
|
203 | 226 | raise ValueError, "The path is not valid" |
|
|
204 | 227 | |
|
|
205 | 228 | if ext == None: |
|
|
206 | 229 | ext = self.ext |
|
|
207 | 230 | |
|
|
208 | 231 | if dataOutObj == None: |
|
|
209 | 232 | dataOutObj = self.createObjByDefault() |
|
|
210 | 233 | |
|
|
211 | 234 | self.dataOutObj = dataOutObj |
|
|
212 | 235 | |
|
|
213 | 236 | if online: |
|
|
214 | 237 | pass |
|
|
215 | 238 | |
|
|
216 | 239 | else: |
|
|
217 | 240 | print "Searching file in offline mode" |
|
|
218 | 241 | pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext) |
|
|
219 | 242 | if not(pathList): |
|
|
220 | 243 | print "No files in range: %s - %s"%(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime()) |
|
|
221 | 244 | return None |
|
|
222 | 245 | self.fileIndex = -1 |
|
|
223 | 246 | self.pathList = pathList |
|
|
224 | 247 | self.filenameList = filenameList |
|
|
225 | 248 | |
|
|
226 | 249 | self.online = online |
|
|
227 | 250 | ext = ext.lower() |
|
|
228 | 251 | self.ext = ext |
|
|
229 | 252 | |
|
|
230 | 253 | if not(self.setNextFile()): |
|
|
231 | 254 | if (startDate!=None) and (endDate!=None): |
|
|
232 | 255 | print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime()) |
|
|
233 | 256 | elif startDate != None: |
|
|
234 | 257 | print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime()) |
|
|
235 | 258 | else: |
|
|
236 | 259 | print "No files" |
|
|
237 | 260 | |
|
|
238 | 261 | return None |
|
|
239 | 262 | |
|
|
240 | self.updateDataHeader() | |
|
|
263 | # self.updateDataHeader() | |
|
|
241 | 264 | |
|
|
242 | 265 | return self.dataOutObj |
|
|
243 | 266 | |
|
|
244 | 267 | def __setNextFileOffline(self): |
|
|
245 | 268 | idFile = self.fileIndex |
|
|
246 | 269 | |
|
|
247 | 270 | while (True): |
|
|
248 | 271 | idFile += 1 |
|
|
249 | 272 | if not(idFile < len(self.filenameList)): |
|
|
250 | 273 | self.flagNoMoreFiles = 1 |
|
|
251 | 274 | print "No more Files" |
|
|
252 | 275 | return 0 |
|
|
253 | 276 | |
|
|
254 | 277 | filename = self.filenameList[idFile] |
|
|
255 | 278 | |
|
|
256 | 279 | if not(self.__verifyFile(filename)): |
|
|
257 | 280 | continue |
|
|
258 | 281 | |
|
|
259 | 282 | fileSize = os.path.getsize(filename) |
|
|
260 | 283 | fp = open(filename,'rb') |
|
|
261 | 284 | break |
|
|
262 | 285 | |
|
|
263 | 286 | self.flagIsNewFile = 1 |
|
|
264 | 287 | self.fileIndex = idFile |
|
|
265 | 288 | self.filename = filename |
|
|
266 | 289 | self.fileSize = fileSize |
|
|
267 | 290 | self.fp = fp |
|
|
268 | 291 | |
|
|
269 | 292 | print "Setting the file: %s"%self.filename |
|
|
270 | 293 | |
|
|
271 | 294 | return 1 |
|
|
272 | 295 | |
|
|
273 | 296 | |
|
|
274 | 297 | |
|
|
275 | 298 | def setNextFile(self): |
|
|
276 | 299 | if self.fp != None: |
|
|
277 | 300 | self.fp.close() |
|
|
278 | 301 | |
|
|
279 | 302 | if self.online: |
|
|
280 | 303 | newFile = self.__setNextFileOnline() |
|
|
281 | 304 | else: |
|
|
282 | 305 | newFile = self.__setNextFileOffline() |
|
|
283 | 306 | |
|
|
284 | 307 | if not(newFile): |
|
|
285 | 308 | return 0 |
|
|
286 | 309 | |
|
|
287 | 310 | self.__readFirstHeader() |
|
|
288 | 311 | self.nReadBlocks = 0 |
|
|
289 | 312 | return 1 |
|
|
290 | 313 | |
|
|
314 | def __setNewBlock(self): | |
|
|
315 | if self.fp == None: | |
|
|
316 | return 0 | |
|
|
317 | ||
|
|
318 | if self.flagIsNewFile: | |
|
|
319 | return 1 | |
|
|
320 | ||
|
|
321 | self.lastUTTime = self.basicHeaderObj.utc | |
|
|
322 | currentSize = self.fileSize - self.fp.tell() | |
|
|
323 | neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize | |
|
|
324 | ||
|
|
325 | if (currentSize >= neededSize): | |
|
|
326 | self.__rdBasicHeader() | |
|
|
327 | return 1 | |
|
|
328 | ||
|
|
329 | if not(self.setNextFile()): | |
|
|
330 | return 0 | |
|
|
331 | ||
|
|
332 | deltaTime = self.basicHeaderObj.utc - self.lastUTTime # | |
|
|
333 | ||
|
|
334 | self.flagTimeBlock = 0 | |
|
|
335 | ||
|
|
336 | if deltaTime > self.maxTimeStep: | |
|
|
337 | self.flagTimeBlock = 1 | |
|
|
338 | ||
|
|
339 | return 1 | |
|
|
340 | ||
|
|
341 | ||
|
|
342 | def readNextBlock(self): | |
|
|
343 | if not(self.__setNewBlock()): | |
|
|
344 | return 0 | |
|
|
345 | ||
|
|
346 | if not(self.readBlock()): | |
|
|
347 | return 0 | |
|
|
348 | ||
|
|
349 | return 1 | |
|
|
350 | ||
|
|
291 | 351 | def __rdProcessingHeader(self, fp=None): |
|
|
292 | 352 | if fp == None: |
|
|
293 | 353 | fp = self.fp |
|
|
294 | 354 | |
|
|
295 | 355 | self.processingHeaderObj.read(fp) |
|
|
296 | 356 | |
|
|
297 | 357 | def __rdRadarControllerHeader(self, fp=None): |
|
|
298 | 358 | if fp == None: |
|
|
299 | 359 | fp = self.fp |
|
|
300 | 360 | |
|
|
301 | 361 | self.radarControllerHeaderObj.read(fp) |
|
|
302 | 362 | |
|
|
303 | 363 | def __rdSystemHeader(self, fp=None): |
|
|
304 | 364 | if fp == None: |
|
|
305 | 365 | fp = self.fp |
|
|
306 | 366 | |
|
|
307 | 367 | self.systemHeaderObj.read(fp) |
|
|
308 | 368 | |
|
|
309 | 369 | def __rdBasicHeader(self, fp=None): |
|
|
310 | 370 | if fp == None: |
|
|
311 | 371 | fp = self.fp |
|
|
312 | 372 | |
|
|
313 | 373 | self.basicHeaderObj.read(fp) |
|
|
314 | 374 | |
|
|
315 | 375 | |
|
|
316 | 376 | def __readFirstHeader(self): |
|
|
317 | 377 | self.__rdBasicHeader() |
|
|
318 | 378 | self.__rdSystemHeader() |
|
|
319 | 379 | self.__rdRadarControllerHeader() |
|
|
320 | 380 | self.__rdProcessingHeader() |
|
|
321 | 381 | |
|
|
322 | 382 | self.firstHeaderSize = self.basicHeaderObj.size |
|
|
323 | 383 | |
|
|
324 | 384 | datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR)) |
|
|
325 | 385 | if datatype == 0: |
|
|
326 | 386 | datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')]) |
|
|
327 | 387 | elif datatype == 1: |
|
|
328 | 388 | datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')]) |
|
|
329 | 389 | elif datatype == 2: |
|
|
330 | 390 | datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')]) |
|
|
331 | 391 | elif datatype == 3: |
|
|
332 | 392 | datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')]) |
|
|
333 | 393 | elif datatype == 4: |
|
|
334 | 394 | datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')]) |
|
|
335 | 395 | elif datatype == 5: |
|
|
336 | 396 | datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')]) |
|
|
337 | 397 | else: |
|
|
338 | 398 | raise ValueError, 'Data type was not defined' |
|
|
339 | 399 | |
|
|
340 | 400 | self.dtype = datatype_str |
|
|
341 | 401 | self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c |
|
|
342 | 402 | self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1) |
|
|
343 | 403 | # self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels) |
|
|
344 | 404 | # self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels) |
|
|
345 | 405 | self.getBlockDimension() |
|
|
346 | 406 | |
|
|
347 | 407 | |
|
|
348 | 408 | def __verifyFile(self, filename, msgFlag=True): |
|
|
349 | 409 | msg = None |
|
|
350 | 410 | try: |
|
|
351 | 411 | fp = open(filename, 'rb') |
|
|
352 | 412 | currentPosition = fp.tell() |
|
|
353 | 413 | except: |
|
|
354 | 414 | if msgFlag: |
|
|
355 | 415 | print "The file %s can't be opened" % (filename) |
|
|
356 | 416 | return False |
|
|
357 | 417 | |
|
|
358 | 418 | neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize |
|
|
359 | 419 | |
|
|
360 | 420 | if neededSize == 0: |
|
|
361 | 421 | basicHeaderObj = BasicHeader() |
|
|
362 | 422 | systemHeaderObj = SystemHeader() |
|
|
363 | 423 | radarControllerHeaderObj = RadarControllerHeader() |
|
|
364 | 424 | processingHeaderObj = ProcessingHeader() |
|
|
365 | 425 | |
|
|
366 | 426 | try: |
|
|
367 | 427 | if not( basicHeaderObj.read(fp) ): raise ValueError |
|
|
368 | 428 | if not( systemHeaderObj.read(fp) ): raise ValueError |
|
|
369 | 429 | if not( radarControllerHeaderObj.read(fp) ): raise ValueError |
|
|
370 | 430 | if not( processingHeaderObj.read(fp) ): raise ValueError |
|
|
371 | 431 | data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR)) |
|
|
372 | 432 | |
|
|
373 | 433 | neededSize = processingHeaderObj.blockSize + basicHeaderObj.size |
|
|
374 | 434 | |
|
|
375 | 435 | except: |
|
|
376 | 436 | if msgFlag: |
|
|
377 | 437 | print "\tThe file %s is empty or it hasn't enough data" % filename |
|
|
378 | 438 | |
|
|
379 | 439 | fp.close() |
|
|
380 | 440 | return False |
|
|
381 | 441 | else: |
|
|
382 | 442 | msg = "\tSkipping the file %s due to it hasn't enough data" %filename |
|
|
383 | 443 | |
|
|
384 | 444 | fp.close() |
|
|
385 | 445 | fileSize = os.path.getsize(filename) |
|
|
386 | 446 | currentSize = fileSize - currentPosition |
|
|
387 | 447 | if currentSize < neededSize: |
|
|
388 | 448 | if msgFlag and (msg != None): |
|
|
389 | 449 | print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename |
|
|
390 | 450 | return False |
|
|
391 | 451 | |
|
|
392 | 452 | return True |
|
|
393 | 453 | |
|
|
394 | 454 | class JRODataWriter(JRODataIO): |
|
|
395 | 455 | |
|
|
396 | 456 | """ |
|
|
397 | 457 | Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura |
|
|
398 | 458 | de los datos siempre se realiza por bloques. |
|
|
399 | 459 | """ |
|
|
400 | 460 | |
|
|
401 | 461 | blockIndex = 0 |
|
|
402 | 462 | |
|
|
403 | 463 | setFile = None |
|
|
404 | 464 | |
|
|
405 | 465 | |
|
|
406 | 466 | def __init__(self, dataOutObj=None): |
|
|
407 | 467 | raise ValueError, "Not implemented" |
|
|
408 | 468 | |
|
|
409 | 469 | |
|
|
410 | 470 | def hasAllDataInBuffer(self): |
|
|
411 | 471 | raise ValueError, "Not implemented" |
|
|
412 | 472 | |
|
|
413 | 473 | |
|
|
414 | 474 | def setBlockDimension(self): |
|
|
415 | 475 | raise ValueError, "Not implemented" |
|
|
416 | 476 | |
|
|
417 | 477 | |
|
|
418 | 478 | def writeBlock(self): |
|
|
419 | 479 | raise ValueError, "No implemented" |
|
|
420 | 480 | |
|
|
421 | 481 | |
|
|
422 | 482 | def putData(self): |
|
|
423 | 483 | raise ValueError, "No implemented" |
|
|
424 | 484 | |
|
|
425 | 485 | |
|
|
426 | 486 | def __writeFirstHeader(self): |
|
|
427 | 487 | """ |
|
|
428 | 488 | Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader) |
|
|
429 | 489 | |
|
|
430 | 490 | Affected: |
|
|
431 | 491 | __dataType |
|
|
432 | 492 | |
|
|
433 | 493 | Return: |
|
|
434 | 494 | None |
|
|
435 | 495 | """ |
|
|
436 | 496 | |
|
|
437 | 497 | # CALCULAR PARAMETROS |
|
|
438 | 498 | |
|
|
439 | 499 | sizeLongHeader = 0#XXXX |
|
|
440 | 500 | self.basicHeaderObj.size = 24 + sizeLongHeader |
|
|
441 | 501 | |
|
|
442 | 502 | self.__writeBasicHeader() |
|
|
443 | 503 | self.__wrSystemHeader() |
|
|
444 | 504 | self.__wrRadarControllerHeader() |
|
|
445 | 505 | self.__wrProcessingHeader() |
|
|
446 | 506 | self.dtype = self.dataOutObj.dtype |
|
|
447 | 507 | |
|
|
448 | 508 | |
|
|
449 | 509 | def __writeBasicHeader(self, fp=None): |
|
|
450 | 510 | """ |
|
|
451 | 511 | Escribe solo el Basic header en el file creado |
|
|
452 | 512 | |
|
|
453 | 513 | Return: |
|
|
454 | 514 | None |
|
|
455 | 515 | """ |
|
|
456 | 516 | if fp == None: |
|
|
457 | 517 | fp = self.fp |
|
|
458 | 518 | |
|
|
459 | 519 | self.dataOutObj.basicHeaderObj.write(fp) |
|
|
460 | 520 | |
|
|
461 | 521 | |
|
|
462 | 522 | def __wrSystemHeader(self, fp=None): |
|
|
463 | 523 | """ |
|
|
464 | 524 | Escribe solo el System header en el file creado |
|
|
465 | 525 | |
|
|
466 | 526 | Return: |
|
|
467 | 527 | None |
|
|
468 | 528 | """ |
|
|
469 | 529 | if fp == None: |
|
|
470 | 530 | fp = self.fp |
|
|
471 | 531 | |
|
|
472 | 532 | self.dataOutObj.systemHeaderObj.write(fp) |
|
|
473 | 533 | |
|
|
474 | 534 | |
|
|
475 | 535 | def __wrRadarControllerHeader(self, fp=None): |
|
|
476 | 536 | """ |
|
|
477 | 537 | Escribe solo el RadarController header en el file creado |
|
|
478 | 538 | |
|
|
479 | 539 | Return: |
|
|
480 | 540 | None |
|
|
481 | 541 | """ |
|
|
482 | 542 | if fp == None: |
|
|
483 | 543 | fp = self.fp |
|
|
484 | 544 | |
|
|
485 | 545 | self.dataOutObj.radarControllerHeaderObj.write(fp) |
|
|
486 | 546 | |
|
|
487 | 547 | |
|
|
488 | 548 | def __wrProcessingHeader(self, fp=None): |
|
|
489 | 549 | """ |
|
|
490 | 550 | Escribe solo el Processing header en el file creado |
|
|
491 | 551 | |
|
|
492 | 552 | Return: |
|
|
493 | 553 | None |
|
|
494 | 554 | """ |
|
|
495 | 555 | if fp == None: |
|
|
496 | 556 | fp = self.fp |
|
|
497 | 557 | |
|
|
498 | 558 | self.dataOutObj.processingHeaderObj.write(fp) |
|
|
499 | 559 | |
|
|
500 | 560 | |
|
|
501 | 561 | def setNextFile(self): |
|
|
502 | 562 | """ |
|
|
503 | 563 | Determina el siguiente file que sera escrito |
|
|
504 | 564 | |
|
|
505 | 565 | Affected: |
|
|
506 | 566 | self.filename |
|
|
507 | 567 | self.subfolder |
|
|
508 | 568 | self.fp |
|
|
509 | 569 | self.setFile |
|
|
510 | 570 | self.flagIsNewFile |
|
|
511 | 571 | |
|
|
512 | 572 | Return: |
|
|
513 | 573 | 0 : Si el archivo no puede ser escrito |
|
|
514 | 574 | 1 : Si el archivo esta listo para ser escrito |
|
|
515 | 575 | """ |
|
|
516 | 576 | ext = self.ext |
|
|
517 | 577 | path = self.path |
|
|
518 | 578 | |
|
|
519 | 579 | if self.fp != None: |
|
|
520 | 580 | self.fp.close() |
|
|
521 | 581 | |
|
|
522 | 582 | timeTuple = time.localtime( self.dataOutObj.dataUtcTime) |
|
|
523 | 583 | subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday) |
|
|
524 | 584 | |
|
|
525 | 585 | doypath = os.path.join( path, subfolder ) |
|
|
526 | 586 | if not( os.path.exists(doypath) ): |
|
|
527 | 587 | os.mkdir(doypath) |
|
|
528 | 588 | self.setFile = -1 #inicializo mi contador de seteo |
|
|
529 | 589 | else: |
|
|
530 | 590 | filesList = os.listdir( doypath ) |
|
|
531 | 591 | if len( filesList ) > 0: |
|
|
532 | 592 | filesList = sorted( filesList, key=str.lower ) |
|
|
533 | 593 | filen = filesList[-1] |
|
|
534 | 594 | # el filename debera tener el siguiente formato |
|
|
535 | 595 | # 0 1234 567 89A BCDE (hex) |
|
|
536 | 596 | # x YYYY DDD SSS .ext |
|
|
537 | 597 | if isNumber( filen[8:11] ): |
|
|
538 | 598 | self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file |
|
|
539 | 599 | else: |
|
|
540 | 600 | self.setFile = -1 |
|
|
541 | 601 | else: |
|
|
542 | 602 | self.setFile = -1 #inicializo mi contador de seteo |
|
|
543 | 603 | |
|
|
544 | 604 | setFile = self.setFile |
|
|
545 | 605 | setFile += 1 |
|
|
546 | 606 | |
|
|
547 | 607 | file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar, |
|
|
548 | 608 | timeTuple.tm_year, |
|
|
549 | 609 | timeTuple.tm_yday, |
|
|
550 | 610 | setFile, |
|
|
551 | 611 | ext ) |
|
|
552 | 612 | |
|
|
553 | 613 | filename = os.path.join( path, subfolder, file ) |
|
|
554 | 614 | |
|
|
555 | 615 | fp = open( filename,'wb' ) |
|
|
556 | 616 | |
|
|
557 | 617 | self.blockIndex = 0 |
|
|
558 | 618 | |
|
|
559 | 619 | #guardando atributos |
|
|
560 | 620 | self.filename = filename |
|
|
561 | 621 | self.subfolder = subfolder |
|
|
562 | 622 | self.fp = fp |
|
|
563 | 623 | self.setFile = setFile |
|
|
564 | 624 | self.flagIsNewFile = 1 |
|
|
565 | 625 | |
|
|
566 | 626 | print 'Writing the file: %s'%self.filename |
|
|
567 | 627 | |
|
|
568 | 628 | self.__writeFirstHeader() |
|
|
569 | 629 | |
|
|
570 | 630 | return 1 |
|
|
571 | 631 | |
|
|
572 | 632 | |
|
|
573 | 633 | def __setNewBlock(self): |
|
|
574 | 634 | """ |
|
|
575 | 635 | Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header |
|
|
576 | 636 | |
|
|
577 | 637 | Return: |
|
|
578 | 638 | 0 : si no pudo escribir nada |
|
|
579 | 639 | 1 : Si escribio el Basic el First Header |
|
|
580 | 640 | """ |
|
|
581 | 641 | if self.fp == None: |
|
|
582 | 642 | self.setNextFile() |
|
|
583 | 643 | |
|
|
584 | 644 | if self.flagIsNewFile: |
|
|
585 | 645 | return 1 |
|
|
586 | 646 | |
|
|
587 | 647 | if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile: |
|
|
588 | 648 | self.__writeBasicHeader() |
|
|
589 | 649 | return 1 |
|
|
590 | 650 | |
|
|
591 | 651 | if not( self.setNextFile() ): |
|
|
592 | 652 | return 0 |
|
|
593 | 653 | |
|
|
594 | 654 | return 1 |
|
|
595 | 655 | |
|
|
596 | 656 | |
|
|
597 | 657 | def writeNextBlock(self): |
|
|
598 | 658 | """ |
|
|
599 | 659 | Selecciona el bloque siguiente de datos y los escribe en un file |
|
|
600 | 660 | |
|
|
601 | 661 | Return: |
|
|
602 | 662 | 0 : Si no hizo pudo escribir el bloque de datos |
|
|
603 | 663 | 1 : Si no pudo escribir el bloque de datos |
|
|
604 | 664 | """ |
|
|
605 | 665 | if not( self.__setNewBlock() ): |
|
|
606 | 666 | return 0 |
|
|
607 | 667 | |
|
|
608 | 668 | self.writeBlock() |
|
|
609 | 669 | |
|
|
610 | 670 | return 1 |
|
|
611 | 671 | |
|
|
612 | 672 | |
|
|
613 | 673 | def getDataHeader(self): |
|
|
614 | 674 | """ |
|
|
615 | 675 | Obtiene una copia del First Header |
|
|
616 | 676 | |
|
|
617 | 677 | Affected: |
|
|
618 | 678 | self.basicHeaderObj |
|
|
619 | 679 | self.systemHeaderObj |
|
|
620 | 680 | self.radarControllerHeaderObj |
|
|
621 | 681 | self.processingHeaderObj |
|
|
622 | 682 | self.dtype |
|
|
623 | 683 | |
|
|
624 | 684 | Return: |
|
|
625 | 685 | None |
|
|
626 | 686 | """ |
|
|
627 | 687 | |
|
|
628 | 688 | raise ValueError, "No implemented" |
|
|
629 | 689 | |
|
|
630 | 690 | def setup(self, path, set=0, ext=None): |
|
|
631 | 691 | """ |
|
|
632 | 692 | Setea el tipo de formato en la cual sera guardada la data y escribe el First Header |
|
|
633 | 693 | |
|
|
634 | 694 | Inputs: |
|
|
635 | 695 | path : el path destino en el cual se escribiran los files a crear |
|
|
636 | 696 | format : formato en el cual sera salvado un file |
|
|
637 | 697 | set : el setebo del file |
|
|
638 | 698 | |
|
|
639 | 699 | Return: |
|
|
640 | 700 | 0 : Si no realizo un buen seteo |
|
|
641 | 701 | 1 : Si realizo un buen seteo |
|
|
642 | 702 | """ |
|
|
643 | 703 | |
|
|
644 | 704 | if ext == None: |
|
|
645 | 705 | ext = self.ext |
|
|
646 | 706 | |
|
|
647 | 707 | ext = ext.lower() |
|
|
648 | 708 | |
|
|
649 | 709 | self.path = path |
|
|
650 | 710 | self.setFile = set - 1 |
|
|
651 | 711 | self.ext = ext |
|
|
652 | 712 | #self.format = format |
|
|
653 | 713 | self.getDataHeader() |
|
|
654 | 714 | |
|
|
655 | 715 | self.setBlockDimension() |
|
|
656 | 716 | |
|
|
657 | 717 | if not( self.setNextFile() ): |
|
|
658 | 718 | print "There isn't a next file" |
|
|
659 | 719 | return 0 |
|
|
660 | 720 | |
|
|
661 | 721 | return 1 |
|
|
662 | 722 | |
|
|
663 | 723 | |
|
|
664 | 724 | |
|
|
665 | 725 | |
|
|
666 | 726 | |
|
|
667 | 727 | |
| @@ -1,506 +1,506 | |||
|
|
1 | 1 | ''' |
|
|
2 | 2 | Created on 23/01/2012 |
|
|
3 | 3 | |
|
|
4 | 4 | @author $Author: vsarmiento $ |
|
|
5 | 5 | @version $Id: HeaderIO.py 37 2012-03-26 22:55:13Z vsarmiento $ |
|
|
6 | 6 | ''' |
|
|
7 | 7 | |
|
|
8 | 8 | import numpy |
|
|
9 | 9 | import copy |
|
|
10 | 10 | |
|
|
11 | 11 | class Header: |
|
|
12 | 12 | |
|
|
13 | 13 | def __init__(self): |
|
|
14 | 14 | raise |
|
|
15 | 15 | |
|
|
16 | 16 | def copy(self): |
|
|
17 | 17 | return copy.deepcopy(self) |
|
|
18 | 18 | |
|
|
19 | 19 | def read(): |
|
|
20 | 20 | pass |
|
|
21 | 21 | |
|
|
22 | 22 | def write(): |
|
|
23 | 23 | pass |
|
|
24 | 24 | |
|
|
25 | 25 | class BasicHeader(Header): |
|
|
26 | 26 | |
|
|
27 | 27 | size = None |
|
|
28 | 28 | version = None |
|
|
29 | 29 | dataBlock = None |
|
|
30 | 30 | utc = None |
|
|
31 | 31 | miliSecond = None |
|
|
32 | 32 | timeZone = None |
|
|
33 | 33 | dstFlag = None |
|
|
34 | 34 | errorCount = None |
|
|
35 | 35 | struct = None |
|
|
36 | 36 | |
|
|
37 | 37 | def __init__(self): |
|
|
38 | 38 | |
|
|
39 | 39 | self.size = 0 |
|
|
40 | 40 | self.version = 0 |
|
|
41 | 41 | self.dataBlock = 0 |
|
|
42 | 42 | self.utc = 0 |
|
|
43 | 43 | self.miliSecond = 0 |
|
|
44 | 44 | self.timeZone = 0 |
|
|
45 | 45 | self.dstFlag = 0 |
|
|
46 | 46 | self.errorCount = 0 |
|
|
47 | 47 | self.struct = numpy.dtype([ |
|
|
48 | 48 | ('nSize','<u4'), |
|
|
49 | 49 | ('nVersion','<u2'), |
|
|
50 | 50 | ('nDataBlockId','<u4'), |
|
|
51 | 51 | ('nUtime','<u4'), |
|
|
52 | 52 | ('nMilsec','<u2'), |
|
|
53 | 53 | ('nTimezone','<i2'), |
|
|
54 | 54 | ('nDstflag','<i2'), |
|
|
55 | 55 | ('nErrorCount','<u4') |
|
|
56 | 56 | ]) |
|
|
57 | 57 | |
|
|
58 | 58 | |
|
|
59 | 59 | def read(self, fp): |
|
|
60 | 60 | try: |
|
|
61 | 61 | header = numpy.fromfile(fp, self.struct,1) |
|
|
62 | 62 | self.size = header['nSize'][0] |
|
|
63 | 63 | self.version = header['nVersion'][0] |
|
|
64 | 64 | self.dataBlock = header['nDataBlockId'][0] |
|
|
65 | 65 | self.utc = header['nUtime'][0] |
|
|
66 | 66 | self.miliSecond = header['nMilsec'][0] |
|
|
67 | 67 | self.timeZone = header['nTimezone'][0] |
|
|
68 | 68 | self.dstFlag = header['nDstflag'][0] |
|
|
69 | 69 | self.errorCount = header['nErrorCount'][0] |
|
|
70 | 70 | except: |
|
|
71 | 71 | return 0 |
|
|
72 | 72 | |
|
|
73 | 73 | return 1 |
|
|
74 | 74 | |
|
|
75 | 75 | def write(self, fp): |
|
|
76 | 76 | headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount) |
|
|
77 | 77 | header = numpy.array(headerTuple,self.struct) |
|
|
78 | 78 | header.tofile(fp) |
|
|
79 | 79 | |
|
|
80 | 80 | return 1 |
|
|
81 | 81 | |
|
|
82 | 82 | class SystemHeader(Header): |
|
|
83 | 83 | |
|
|
84 | 84 | size = None |
|
|
85 | 85 | nSamples = None |
|
|
86 | 86 | nProfiles = None |
|
|
87 | 87 | nChannels = None |
|
|
88 | 88 | adcResolution = None |
|
|
89 | 89 | pciDioBusWidth = None |
|
|
90 | 90 | struct = None |
|
|
91 | 91 | |
|
|
92 | 92 | def __init__(self): |
|
|
93 | 93 | self.size = 0 |
|
|
94 | 94 | self.nSamples = 0 |
|
|
95 | 95 | self.nProfiles = 0 |
|
|
96 | 96 | self.nChannels = 0 |
|
|
97 | 97 | self.adcResolution = 0 |
|
|
98 | 98 | self.pciDioBusWidth = 0 |
|
|
99 | 99 | self.struct = numpy.dtype([ |
|
|
100 | 100 | ('nSize','<u4'), |
|
|
101 | 101 | ('nNumSamples','<u4'), |
|
|
102 | 102 | ('nNumProfiles','<u4'), |
|
|
103 | 103 | ('nNumChannels','<u4'), |
|
|
104 | 104 | ('nADCResolution','<u4'), |
|
|
105 | 105 | ('nPCDIOBusWidth','<u4'), |
|
|
106 | 106 | ]) |
|
|
107 | 107 | |
|
|
108 | 108 | |
|
|
109 | 109 | def read(self, fp): |
|
|
110 | 110 | try: |
|
|
111 | 111 | header = numpy.fromfile(fp,self.struct,1) |
|
|
112 | 112 | self.size = header['nSize'][0] |
|
|
113 | 113 | self.nSamples = header['nNumSamples'][0] |
|
|
114 | 114 | self.nProfiles = header['nNumProfiles'][0] |
|
|
115 | 115 | self.nChannels = header['nNumChannels'][0] |
|
|
116 | 116 | self.adcResolution = header['nADCResolution'][0] |
|
|
117 | 117 | self.pciDioBusWidth = header['nPCDIOBusWidth'][0] |
|
|
118 | 118 | except: |
|
|
119 | 119 | return 0 |
|
|
120 | 120 | |
|
|
121 | 121 | return 1 |
|
|
122 | 122 | |
|
|
123 | 123 | def write(self, fp): |
|
|
124 | 124 | headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth) |
|
|
125 | 125 | header = numpy.array(headerTuple,self.struct) |
|
|
126 | 126 | header.tofile(fp) |
|
|
127 | 127 | |
|
|
128 | 128 | return 1 |
|
|
129 | 129 | |
|
|
130 | 130 | class RadarControllerHeader(Header): |
|
|
131 | 131 | |
|
|
132 | 132 | size = None |
|
|
133 | 133 | expType = None |
|
|
134 | 134 | nTx = None |
|
|
135 | 135 | ipp = None |
|
|
136 | 136 | txA = None |
|
|
137 | 137 | txB = None |
|
|
138 | 138 | nWindows = None |
|
|
139 | 139 | numTaus = None |
|
|
140 | 140 | codeType = None |
|
|
141 | 141 | line6Function = None |
|
|
142 | 142 | line5Function = None |
|
|
143 | 143 | fClock = None |
|
|
144 | 144 | prePulseBefore = None |
|
|
145 | 145 | prePulserAfter = None |
|
|
146 | 146 | rangeIpp = None |
|
|
147 | 147 | rangeTxA = None |
|
|
148 | 148 | rangeTxB = None |
|
|
149 | 149 | struct = None |
|
|
150 | 150 | |
|
|
151 | 151 | def __init__(self): |
|
|
152 | 152 | self.size = 0 |
|
|
153 | 153 | self.expType = 0 |
|
|
154 | 154 | self.nTx = 0 |
|
|
155 | 155 | self.ipp = 0 |
|
|
156 | 156 | self.txA = 0 |
|
|
157 | 157 | self.txB = 0 |
|
|
158 | 158 | self.nWindows = 0 |
|
|
159 | 159 | self.numTaus = 0 |
|
|
160 | 160 | self.codeType = 0 |
|
|
161 | 161 | self.line6Function = 0 |
|
|
162 | 162 | self.line5Function = 0 |
|
|
163 | 163 | self.fClock = 0 |
|
|
164 | 164 | self.prePulseBefore = 0 |
|
|
165 | 165 | self.prePulserAfter = 0 |
|
|
166 | 166 | self.rangeIpp = 0 |
|
|
167 | 167 | self.rangeTxA = 0 |
|
|
168 | 168 | self.rangeTxB = 0 |
|
|
169 | 169 | self.struct = numpy.dtype([ |
|
|
170 | 170 | ('nSize','<u4'), |
|
|
171 | 171 | ('nExpType','<u4'), |
|
|
172 | 172 | ('nNTx','<u4'), |
|
|
173 | 173 | ('fIpp','<f4'), |
|
|
174 | 174 | ('fTxA','<f4'), |
|
|
175 | 175 | ('fTxB','<f4'), |
|
|
176 | 176 | ('nNumWindows','<u4'), |
|
|
177 | 177 | ('nNumTaus','<u4'), |
|
|
178 | 178 | ('nCodeType','<u4'), |
|
|
179 | 179 | ('nLine6Function','<u4'), |
|
|
180 | 180 | ('nLine5Function','<u4'), |
|
|
181 | 181 | ('fClock','<f4'), |
|
|
182 | 182 | ('nPrePulseBefore','<u4'), |
|
|
183 | 183 | ('nPrePulseAfter','<u4'), |
|
|
184 | 184 | ('sRangeIPP','<a20'), |
|
|
185 | 185 | ('sRangeTxA','<a20'), |
|
|
186 | 186 | ('sRangeTxB','<a20'), |
|
|
187 | 187 | ]) |
|
|
188 | 188 | |
|
|
189 | 189 | self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')]) |
|
|
190 | 190 | |
|
|
191 | 191 | self.samplingWindow = None |
|
|
192 |
self.n |
|
|
|
192 | self.nHeights = None | |
|
|
193 | 193 | self.firstHeight = None |
|
|
194 | 194 | self.deltaHeight = None |
|
|
195 | 195 | self.samplesWin = None |
|
|
196 | 196 | |
|
|
197 | 197 | self.numCode = None |
|
|
198 | 198 | self.numBaud = None |
|
|
199 | 199 | self.code = None |
|
|
200 | 200 | self.flip1 = None |
|
|
201 | 201 | self.flip2 = None |
|
|
202 | 202 | |
|
|
203 | 203 | self.dynamic = numpy.array([],numpy.dtype('byte')) |
|
|
204 | 204 | |
|
|
205 | 205 | |
|
|
206 | 206 | def read(self, fp): |
|
|
207 | 207 | try: |
|
|
208 | 208 | startFp = fp.tell() |
|
|
209 | 209 | header = numpy.fromfile(fp,self.struct,1) |
|
|
210 | 210 | self.size = header['nSize'][0] |
|
|
211 | 211 | self.expType = header['nExpType'][0] |
|
|
212 | 212 | self.nTx = header['nNTx'][0] |
|
|
213 | 213 | self.ipp = header['fIpp'][0] |
|
|
214 | 214 | self.txA = header['fTxA'][0] |
|
|
215 | 215 | self.txB = header['fTxB'][0] |
|
|
216 | 216 | self.nWindows = header['nNumWindows'][0] |
|
|
217 | 217 | self.numTaus = header['nNumTaus'][0] |
|
|
218 | 218 | self.codeType = header['nCodeType'][0] |
|
|
219 | 219 | self.line6Function = header['nLine6Function'][0] |
|
|
220 | 220 | self.line5Function = header['nLine5Function'][0] |
|
|
221 | 221 | self.fClock = header['fClock'][0] |
|
|
222 | 222 | self.prePulseBefore = header['nPrePulseBefore'][0] |
|
|
223 | 223 | self.prePulserAfter = header['nPrePulseAfter'][0] |
|
|
224 | 224 | self.rangeIpp = header['sRangeIPP'][0] |
|
|
225 | 225 | self.rangeTxA = header['sRangeTxA'][0] |
|
|
226 | 226 | self.rangeTxB = header['sRangeTxB'][0] |
|
|
227 | 227 | # jump Dynamic Radar Controller Header |
|
|
228 | 228 | jumpFp = self.size - 116 |
|
|
229 | 229 | self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp) |
|
|
230 | 230 | #pointer backward to dynamic header and read |
|
|
231 | 231 | backFp = fp.tell() - jumpFp |
|
|
232 | 232 | fp.seek(backFp) |
|
|
233 | 233 | |
|
|
234 | 234 | self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows) |
|
|
235 |
self.n |
|
|
|
235 | self.nHeights = numpy.sum(self.samplingWindow['nsa']) | |
|
|
236 | 236 | self.firstHeight = self.samplingWindow['h0'] |
|
|
237 | 237 | self.deltaHeight = self.samplingWindow['dh'] |
|
|
238 | 238 | self.samplesWin = self.samplingWindow['nsa'] |
|
|
239 | 239 | |
|
|
240 | 240 | self.Taus = numpy.fromfile(fp,'<f4',self.numTaus) |
|
|
241 | 241 | |
|
|
242 | 242 | if self.codeType != 0: |
|
|
243 | 243 | self.numCode = numpy.fromfile(fp,'<u4',1) |
|
|
244 | 244 | self.numBaud = numpy.fromfile(fp,'<u4',1) |
|
|
245 | 245 | self.code = numpy.empty([self.numCode,self.numBaud],dtype='u1') |
|
|
246 | 246 | tempList = [] |
|
|
247 | 247 | for ic in range(self.numCode): |
|
|
248 | 248 | temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.numBaud/32.)) |
|
|
249 | 249 | tempList.append(temp) |
|
|
250 | 250 | self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.numBaud:] |
|
|
251 | 251 | self.code = 2.0*self.code - 1.0 |
|
|
252 | 252 | |
|
|
253 | 253 | if self.line5Function == RCfunction.FLIP: |
|
|
254 | 254 | self.flip1 = numpy.fromfile(fp,'<u4',1) |
|
|
255 | 255 | |
|
|
256 | 256 | if self.line6Function == RCfunction.FLIP: |
|
|
257 | 257 | self.flip2 = numpy.fromfile(fp,'<u4',1) |
|
|
258 | 258 | |
|
|
259 | 259 | endFp = self.size + startFp |
|
|
260 | 260 | jumpFp = endFp - fp.tell() |
|
|
261 | 261 | if jumpFp > 0: |
|
|
262 | 262 | fp.seek(jumpFp) |
|
|
263 | 263 | |
|
|
264 | 264 | except: |
|
|
265 | 265 | return 0 |
|
|
266 | 266 | |
|
|
267 | 267 | return 1 |
|
|
268 | 268 | |
|
|
269 | 269 | def write(self, fp): |
|
|
270 | 270 | headerTuple = (self.size, |
|
|
271 | 271 | self.expType, |
|
|
272 | 272 | self.nTx, |
|
|
273 | 273 | self.ipp, |
|
|
274 | 274 | self.txA, |
|
|
275 | 275 | self.txB, |
|
|
276 | 276 | self.nWindows, |
|
|
277 | 277 | self.numTaus, |
|
|
278 | 278 | self.codeType, |
|
|
279 | 279 | self.line6Function, |
|
|
280 | 280 | self.line5Function, |
|
|
281 | 281 | self.fClock, |
|
|
282 | 282 | self.prePulseBefore, |
|
|
283 | 283 | self.prePulserAfter, |
|
|
284 | 284 | self.rangeIpp, |
|
|
285 | 285 | self.rangeTxA, |
|
|
286 | 286 | self.rangeTxB) |
|
|
287 | 287 | |
|
|
288 | 288 | header = numpy.array(headerTuple,self.struct) |
|
|
289 | 289 | header.tofile(fp) |
|
|
290 | 290 | |
|
|
291 | 291 | dynamic = self.dynamic |
|
|
292 | 292 | dynamic.tofile(fp) |
|
|
293 | 293 | |
|
|
294 | 294 | return 1 |
|
|
295 | 295 | |
|
|
296 | 296 | |
|
|
297 | 297 | |
|
|
298 | 298 | class ProcessingHeader(Header): |
|
|
299 | 299 | |
|
|
300 | 300 | size = None |
|
|
301 | 301 | dtype = None |
|
|
302 | 302 | blockSize = None |
|
|
303 | 303 | profilesPerBlock = None |
|
|
304 | 304 | dataBlocksPerFile = None |
|
|
305 | 305 | nWindows = None |
|
|
306 | 306 | processFlags = None |
|
|
307 | 307 | nCohInt = None |
|
|
308 | 308 | nIncohInt = None |
|
|
309 | 309 | totalSpectra = None |
|
|
310 | 310 | struct = None |
|
|
311 | 311 | flag_dc = None |
|
|
312 | 312 | flag_cspc = None |
|
|
313 | 313 | |
|
|
314 | 314 | def __init__(self): |
|
|
315 | 315 | self.size = 0 |
|
|
316 | 316 | self.dataType = 0 |
|
|
317 | 317 | self.blockSize = 0 |
|
|
318 | 318 | self.profilesPerBlock = 0 |
|
|
319 | 319 | self.dataBlocksPerFile = 0 |
|
|
320 | 320 | self.nWindows = 0 |
|
|
321 | 321 | self.processFlags = 0 |
|
|
322 | 322 | self.nCohInt = 0 |
|
|
323 | 323 | self.nIncohInt = 0 |
|
|
324 | 324 | self.totalSpectra = 0 |
|
|
325 | 325 | self.struct = numpy.dtype([ |
|
|
326 | 326 | ('nSize','<u4'), |
|
|
327 | 327 | ('nDataType','<u4'), |
|
|
328 | 328 | ('nSizeOfDataBlock','<u4'), |
|
|
329 | 329 | ('nProfilesperBlock','<u4'), |
|
|
330 | 330 | ('nDataBlocksperFile','<u4'), |
|
|
331 | 331 | ('nNumWindows','<u4'), |
|
|
332 | 332 | ('nProcessFlags','<u4'), |
|
|
333 | 333 | ('nCoherentIntegrations','<u4'), |
|
|
334 | 334 | ('nIncoherentIntegrations','<u4'), |
|
|
335 | 335 | ('nTotalSpectra','<u4') |
|
|
336 | 336 | ]) |
|
|
337 | 337 | self.samplingWindow = 0 |
|
|
338 | 338 | self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')]) |
|
|
339 |
self.n |
|
|
|
339 | self.nHeights = 0 | |
|
|
340 | 340 | self.firstHeight = 0 |
|
|
341 | 341 | self.deltaHeight = 0 |
|
|
342 | 342 | self.samplesWin = 0 |
|
|
343 | 343 | self.spectraComb = 0 |
|
|
344 | 344 | self.numCode = 0 |
|
|
345 | 345 | self.code = 0 |
|
|
346 | 346 | self.numBaud = 0 |
|
|
347 | 347 | self.shif_fft = False |
|
|
348 | 348 | self.flag_dc = False |
|
|
349 | 349 | self.flag_cspc = False |
|
|
350 | 350 | |
|
|
351 | 351 | def read(self, fp): |
|
|
352 | 352 | try: |
|
|
353 | 353 | header = numpy.fromfile(fp,self.struct,1) |
|
|
354 | 354 | self.size = header['nSize'][0] |
|
|
355 | 355 | self.dataType = header['nDataType'][0] |
|
|
356 | 356 | self.blockSize = header['nSizeOfDataBlock'][0] |
|
|
357 | 357 | self.profilesPerBlock = header['nProfilesperBlock'][0] |
|
|
358 | 358 | self.dataBlocksPerFile = header['nDataBlocksperFile'][0] |
|
|
359 | 359 | self.nWindows = header['nNumWindows'][0] |
|
|
360 | 360 | self.processFlags = header['nProcessFlags'] |
|
|
361 | 361 | self.nCohInt = header['nCoherentIntegrations'][0] |
|
|
362 | 362 | self.nIncohInt = header['nIncoherentIntegrations'][0] |
|
|
363 | 363 | self.totalSpectra = header['nTotalSpectra'][0] |
|
|
364 | 364 | self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows) |
|
|
365 |
self.n |
|
|
|
366 | self.firstHeight = self.samplingWindow['h0'] | |
|
|
367 | self.deltaHeight = self.samplingWindow['dh'] | |
|
|
365 | self.nHeights = numpy.sum(self.samplingWindow['nsa']) | |
|
|
366 | self.firstHeight = self.samplingWindow['h0'][0] | |
|
|
367 | self.deltaHeight = self.samplingWindow['dh'][0] | |
|
|
368 | 368 | self.samplesWin = self.samplingWindow['nsa'] |
|
|
369 | 369 | self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra) |
|
|
370 | 370 | |
|
|
371 | 371 | if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE): |
|
|
372 | 372 | self.numCode = numpy.fromfile(fp,'<u4',1) |
|
|
373 | 373 | self.numBaud = numpy.fromfile(fp,'<u4',1) |
|
|
374 | 374 | self.code = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode) |
|
|
375 | 375 | |
|
|
376 | 376 | if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA): |
|
|
377 | 377 | self.shif_fft = True |
|
|
378 | 378 | else: |
|
|
379 | 379 | self.shif_fft = False |
|
|
380 | 380 | |
|
|
381 | 381 | if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC): |
|
|
382 | 382 | self.flag_dc = True |
|
|
383 | 383 | |
|
|
384 | 384 | nChannels = 0 |
|
|
385 | 385 | nPairs = 0 |
|
|
386 | 386 | pairList = [] |
|
|
387 | 387 | |
|
|
388 | 388 | for i in range( 0, self.totalSpectra*2, 2 ): |
|
|
389 | 389 | if self.spectraComb[i] == self.spectraComb[i+1]: |
|
|
390 | 390 | nChannels = nChannels + 1 #par de canales iguales |
|
|
391 | 391 | else: |
|
|
392 | 392 | nPairs = nPairs + 1 #par de canales diferentes |
|
|
393 | 393 | pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) ) |
|
|
394 | 394 | |
|
|
395 | 395 | self.flag_cspc = False |
|
|
396 | 396 | if nPairs > 0: |
|
|
397 | 397 | self.flag_cspc = True |
|
|
398 | 398 | |
|
|
399 | 399 | except: |
|
|
400 | 400 | return 0 |
|
|
401 | 401 | |
|
|
402 | 402 | return 1 |
|
|
403 | 403 | |
|
|
404 | 404 | def write(self, fp): |
|
|
405 | 405 | headerTuple = (self.size, |
|
|
406 | 406 | self.dataType, |
|
|
407 | 407 | self.blockSize, |
|
|
408 | 408 | self.profilesPerBlock, |
|
|
409 | 409 | self.dataBlocksPerFile, |
|
|
410 | 410 | self.nWindows, |
|
|
411 | 411 | self.processFlags, |
|
|
412 | 412 | self.nCohInt, |
|
|
413 | 413 | self.nIncohInt, |
|
|
414 | 414 | self.totalSpectra) |
|
|
415 | 415 | |
|
|
416 | 416 | header = numpy.array(headerTuple,self.struct) |
|
|
417 | 417 | header.tofile(fp) |
|
|
418 | 418 | |
|
|
419 | 419 | if self.nWindows != 0: |
|
|
420 | 420 | sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin) |
|
|
421 | 421 | samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow) |
|
|
422 | 422 | samplingWindow.tofile(fp) |
|
|
423 | 423 | |
|
|
424 | 424 | |
|
|
425 | 425 | if self.totalSpectra != 0: |
|
|
426 | 426 | spectraComb = numpy.array([],numpy.dtype('u1')) |
|
|
427 | 427 | spectraComb = self.spectraComb |
|
|
428 | 428 | spectraComb.tofile(fp) |
|
|
429 | 429 | |
|
|
430 | 430 | |
|
|
431 | 431 | if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE: |
|
|
432 | 432 | numCode = self.numCode |
|
|
433 | 433 | numCode.tofile(fp) |
|
|
434 | 434 | |
|
|
435 | 435 | numBaud = self.numBaud |
|
|
436 | 436 | numBaud.tofile(fp) |
|
|
437 | 437 | |
|
|
438 | 438 | code = self.code.reshape(numCode*numBaud) |
|
|
439 | 439 | code.tofile(fp) |
|
|
440 | 440 | |
|
|
441 | 441 | return 1 |
|
|
442 | 442 | |
|
|
443 | 443 | class RCfunction: |
|
|
444 | 444 | NONE=0 |
|
|
445 | 445 | FLIP=1 |
|
|
446 | 446 | CODE=2 |
|
|
447 | 447 | SAMPLING=3 |
|
|
448 | 448 | LIN6DIV256=4 |
|
|
449 | 449 | SYNCHRO=5 |
|
|
450 | 450 | |
|
|
451 | 451 | class nCodeType: |
|
|
452 | 452 | NONE=0 |
|
|
453 | 453 | USERDEFINE=1 |
|
|
454 | 454 | BARKER2=2 |
|
|
455 | 455 | BARKER3=3 |
|
|
456 | 456 | BARKER4=4 |
|
|
457 | 457 | BARKER5=5 |
|
|
458 | 458 | BARKER7=6 |
|
|
459 | 459 | BARKER11=7 |
|
|
460 | 460 | BARKER13=8 |
|
|
461 | 461 | AC128=9 |
|
|
462 | 462 | COMPLEMENTARYCODE2=10 |
|
|
463 | 463 | COMPLEMENTARYCODE4=11 |
|
|
464 | 464 | COMPLEMENTARYCODE8=12 |
|
|
465 | 465 | COMPLEMENTARYCODE16=13 |
|
|
466 | 466 | COMPLEMENTARYCODE32=14 |
|
|
467 | 467 | COMPLEMENTARYCODE64=15 |
|
|
468 | 468 | COMPLEMENTARYCODE128=16 |
|
|
469 | 469 | CODE_BINARY28=17 |
|
|
470 | 470 | |
|
|
471 | 471 | class PROCFLAG: |
|
|
472 | 472 | COHERENT_INTEGRATION = numpy.uint32(0x00000001) |
|
|
473 | 473 | DECODE_DATA = numpy.uint32(0x00000002) |
|
|
474 | 474 | SPECTRA_CALC = numpy.uint32(0x00000004) |
|
|
475 | 475 | INCOHERENT_INTEGRATION = numpy.uint32(0x00000008) |
|
|
476 | 476 | POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010) |
|
|
477 | 477 | SHIFT_FFT_DATA = numpy.uint32(0x00000020) |
|
|
478 | 478 | |
|
|
479 | 479 | DATATYPE_CHAR = numpy.uint32(0x00000040) |
|
|
480 | 480 | DATATYPE_SHORT = numpy.uint32(0x00000080) |
|
|
481 | 481 | DATATYPE_LONG = numpy.uint32(0x00000100) |
|
|
482 | 482 | DATATYPE_INT64 = numpy.uint32(0x00000200) |
|
|
483 | 483 | DATATYPE_FLOAT = numpy.uint32(0x00000400) |
|
|
484 | 484 | DATATYPE_DOUBLE = numpy.uint32(0x00000800) |
|
|
485 | 485 | |
|
|
486 | 486 | DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000) |
|
|
487 | 487 | DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000) |
|
|
488 | 488 | DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000) |
|
|
489 | 489 | |
|
|
490 | 490 | SAVE_CHANNELS_DC = numpy.uint32(0x00008000) |
|
|
491 | 491 | DEFLIP_DATA = numpy.uint32(0x00010000) |
|
|
492 | 492 | DEFINE_PROCESS_CODE = numpy.uint32(0x00020000) |
|
|
493 | 493 | |
|
|
494 | 494 | ACQ_SYS_NATALIA = numpy.uint32(0x00040000) |
|
|
495 | 495 | ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000) |
|
|
496 | 496 | ACQ_SYS_ADRXD = numpy.uint32(0x000C0000) |
|
|
497 | 497 | ACQ_SYS_JULIA = numpy.uint32(0x00100000) |
|
|
498 | 498 | ACQ_SYS_XXXXXX = numpy.uint32(0x00140000) |
|
|
499 | 499 | |
|
|
500 | 500 | EXP_NAME_ESP = numpy.uint32(0x00200000) |
|
|
501 | 501 | CHANNEL_NAMES_ESP = numpy.uint32(0x00400000) |
|
|
502 | 502 | |
|
|
503 | 503 | OPERATION_MASK = numpy.uint32(0x0000003F) |
|
|
504 | 504 | DATATYPE_MASK = numpy.uint32(0x00000FC0) |
|
|
505 | 505 | DATAARRANGE_MASK = numpy.uint32(0x00007000) |
|
|
506 | 506 | ACQ_SYS_MASK = numpy.uint32(0x001C0000) No newline at end of file |
| @@ -1,494 +1,490 | |||
|
|
1 | 1 | ''' |
|
|
2 | 2 | Created on 23/01/2012 |
|
|
3 | 3 | |
|
|
4 | 4 | @author $Author: dsuarez $ |
|
|
5 | 5 | @version $Id: VoltageIO.py 110 2012-07-19 15:18:18Z dsuarez $ |
|
|
6 | 6 | ''' |
|
|
7 | 7 | |
|
|
8 | 8 | import os, sys |
|
|
9 | 9 | import numpy |
|
|
10 | 10 | import glob |
|
|
11 | 11 | import fnmatch |
|
|
12 | 12 | import time, datetime |
|
|
13 | 13 | |
|
|
14 | 14 | path = os.path.split(os.getcwd())[0] |
|
|
15 | 15 | sys.path.append(path) |
|
|
16 | 16 | |
|
|
17 | 17 | from JROHeader import * |
|
|
18 | 18 | from JRODataIO import JRODataReader |
|
|
19 | 19 | from JRODataIO import JRODataWriter |
|
|
20 | 20 | |
|
|
21 | 21 | from Data.Voltage import Voltage |
|
|
22 | 22 | |
|
|
23 | 23 | class VoltageReader(JRODataReader): |
|
|
24 | 24 | """ |
|
|
25 | 25 | Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura |
|
|
26 | 26 | de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones: |
|
|
27 | 27 | perfiles*alturas*canales) son almacenados en la variable "buffer". |
|
|
28 | 28 | |
|
|
29 | 29 | perfiles * alturas * canales |
|
|
30 | 30 | |
|
|
31 | 31 | Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader, |
|
|
32 | 32 | RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la |
|
|
33 | 33 | cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de |
|
|
34 | 34 | datos desde el "buffer" cada vez que se ejecute el metodo "getData". |
|
|
35 | 35 | |
|
|
36 | 36 | Example: |
|
|
37 | 37 | |
|
|
38 | 38 | dpath = "/home/myuser/data" |
|
|
39 | 39 | |
|
|
40 | 40 | startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0) |
|
|
41 | 41 | |
|
|
42 | 42 | endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0) |
|
|
43 | 43 | |
|
|
44 | 44 | readerObj = VoltageReader() |
|
|
45 | 45 | |
|
|
46 | 46 | readerObj.setup(dpath, startTime, endTime) |
|
|
47 | 47 | |
|
|
48 | 48 | while(True): |
|
|
49 | 49 | |
|
|
50 | 50 | #to get one profile |
|
|
51 | 51 | profile = readerObj.getData() |
|
|
52 | 52 | |
|
|
53 | 53 | #print the profile |
|
|
54 | 54 | print profile |
|
|
55 | 55 | |
|
|
56 | 56 | #If you want to see all datablock |
|
|
57 | 57 | print readerObj.datablock |
|
|
58 | 58 | |
|
|
59 | 59 | if readerObj.flagNoMoreFiles: |
|
|
60 | 60 | break |
|
|
61 | 61 | |
|
|
62 | 62 | """ |
|
|
63 | 63 | dataOutObj = None |
|
|
64 | 64 | |
|
|
65 | 65 | datablock = None |
|
|
66 | 66 | |
|
|
67 | 67 | ext = ".r" |
|
|
68 | 68 | |
|
|
69 | 69 | optchar = "D" |
|
|
70 | 70 | |
|
|
71 | 71 | |
|
|
72 | 72 | def __init__(self, dataOutObj=None): |
|
|
73 | 73 | """ |
|
|
74 | 74 | Inicializador de la clase VoltageReader para la lectura de datos de voltage. |
|
|
75 | 75 | |
|
|
76 | 76 | Input: |
|
|
77 | 77 | dataOutObj : Objeto de la clase Voltage. Este objeto sera utilizado para |
|
|
78 | 78 | almacenar un perfil de datos cada vez que se haga un requerimiento |
|
|
79 | 79 | (getData). El perfil sera obtenido a partir del buffer de datos, |
|
|
80 | 80 | si el buffer esta vacio se hara un nuevo proceso de lectura de un |
|
|
81 | 81 | bloque de datos. |
|
|
82 | 82 | Si este parametro no es pasado se creara uno internamente. |
|
|
83 | 83 | |
|
|
84 | 84 | Variables afectadas: |
|
|
85 | 85 | self.dataOutObj |
|
|
86 | 86 | |
|
|
87 | 87 | Return: |
|
|
88 | 88 | None |
|
|
89 | 89 | """ |
|
|
90 | 90 | |
|
|
91 | 91 | self.datablock = None |
|
|
92 | 92 | |
|
|
93 | 93 | self.utc = 0 |
|
|
94 | 94 | |
|
|
95 | 95 | self.ext = ".r" |
|
|
96 | 96 | |
|
|
97 | 97 | self.optchar = "D" |
|
|
98 | 98 | |
|
|
99 | 99 | self.basicHeaderObj = BasicHeader() |
|
|
100 | 100 | |
|
|
101 | 101 | self.systemHeaderObj = SystemHeader() |
|
|
102 | 102 | |
|
|
103 | 103 | self.radarControllerHeaderObj = RadarControllerHeader() |
|
|
104 | 104 | |
|
|
105 | 105 | self.processingHeaderObj = ProcessingHeader() |
|
|
106 | 106 | |
|
|
107 | 107 | self.online = 0 |
|
|
108 | 108 | |
|
|
109 | 109 | self.fp = None |
|
|
110 | 110 | |
|
|
111 | 111 | self.idFile = None |
|
|
112 | 112 | |
|
|
113 | self.startDateTime = None | |
|
|
114 | ||
|
|
115 | self.endDateTime = None | |
|
|
116 | ||
|
|
117 | 113 | self.dtype = None |
|
|
118 | 114 | |
|
|
119 | 115 | self.fileSizeByHeader = None |
|
|
120 | 116 | |
|
|
121 | 117 | self.filenameList = [] |
|
|
122 | 118 | |
|
|
123 | 119 | self.filename = None |
|
|
124 | 120 | |
|
|
125 | 121 | self.fileSize = None |
|
|
126 | 122 | |
|
|
127 | 123 | self.firstHeaderSize = 0 |
|
|
128 | 124 | |
|
|
129 | 125 | self.basicHeaderSize = 24 |
|
|
130 | 126 | |
|
|
131 | 127 | self.pathList = [] |
|
|
132 | 128 | |
|
|
133 | 129 | self.filenameList = [] |
|
|
134 | 130 | |
|
|
135 | 131 | self.lastUTTime = 0 |
|
|
136 | 132 | |
|
|
137 | 133 | self.maxTimeStep = 30 |
|
|
138 | 134 | |
|
|
139 | 135 | self.flagNoMoreFiles = 0 |
|
|
140 | 136 | |
|
|
141 | 137 | self.set = 0 |
|
|
142 | 138 | |
|
|
143 | 139 | self.path = None |
|
|
144 | 140 | |
|
|
145 | 141 | self.profileIndex = 9999 |
|
|
146 | 142 | |
|
|
147 | 143 | self.delay = 3 #seconds |
|
|
148 | 144 | |
|
|
149 | 145 | self.nTries = 3 #quantity tries |
|
|
150 | 146 | |
|
|
151 | 147 | self.nFiles = 3 #number of files for searching |
|
|
152 | 148 | |
|
|
153 | 149 | self.nReadBlocks = 0 |
|
|
154 | 150 | |
|
|
155 | 151 | self.flagIsNewFile = 1 |
|
|
156 | 152 | |
|
|
157 | 153 | self.ippSeconds = 0 |
|
|
158 | 154 | |
|
|
159 | 155 | self.flagTimeBlock = 0 |
|
|
160 | 156 | |
|
|
161 | 157 | self.flagIsNewBlock = 0 |
|
|
162 | 158 | |
|
|
163 | 159 | self.nTotalBlocks = 0 |
|
|
164 | 160 | |
|
|
165 | 161 | self.blocksize = 0 |
|
|
166 | 162 | |
|
|
167 | 163 | def createObjByDefault(self): |
|
|
168 | 164 | |
|
|
169 | 165 | dataObj = Voltage() |
|
|
170 | 166 | |
|
|
171 | 167 | return dataObj |
|
|
172 | 168 | |
|
|
173 | 169 | def __hasNotDataInBuffer(self): |
|
|
174 | 170 | if self.profileIndex >= self.processingHeaderObj.profilesPerBlock: |
|
|
175 | 171 | return 1 |
|
|
176 | 172 | return 0 |
|
|
177 | 173 | |
|
|
178 | 174 | |
|
|
179 | 175 | def getBlockDimension(self): |
|
|
180 | 176 | """ |
|
|
181 | 177 | Obtiene la cantidad de puntos a leer por cada bloque de datos |
|
|
182 | 178 | |
|
|
183 | 179 | Affected: |
|
|
184 | 180 | self.blocksize |
|
|
185 | 181 | |
|
|
186 | 182 | Return: |
|
|
187 | 183 | None |
|
|
188 | 184 | """ |
|
|
189 |
pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.n |
|
|
|
185 | pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels | |
|
|
190 | 186 | self.blocksize = pts2read |
|
|
191 | 187 | |
|
|
192 | 188 | |
|
|
193 | 189 | def readBlock(self): |
|
|
194 | 190 | """ |
|
|
195 | 191 | readBlock lee el bloque de datos desde la posicion actual del puntero del archivo |
|
|
196 | 192 | (self.fp) y actualiza todos los parametros relacionados al bloque de datos |
|
|
197 | 193 | (metadata + data). La data leida es almacenada en el buffer y el contador del buffer |
|
|
198 | 194 | es seteado a 0 |
|
|
199 | 195 | |
|
|
200 | 196 | Inputs: |
|
|
201 | 197 | None |
|
|
202 | 198 | |
|
|
203 | 199 | Return: |
|
|
204 | 200 | None |
|
|
205 | 201 | |
|
|
206 | 202 | Affected: |
|
|
207 | 203 | self.profileIndex |
|
|
208 | 204 | self.datablock |
|
|
209 | 205 | self.flagIsNewFile |
|
|
210 | 206 | self.flagIsNewBlock |
|
|
211 | 207 | self.nTotalBlocks |
|
|
212 | 208 | |
|
|
213 | 209 | Exceptions: |
|
|
214 | 210 | Si un bloque leido no es un bloque valido |
|
|
215 | 211 | """ |
|
|
216 | 212 | |
|
|
217 | 213 | junk = numpy.fromfile( self.fp, self.dtype, self.blocksize ) |
|
|
218 | 214 | |
|
|
219 | 215 | try: |
|
|
220 |
junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.n |
|
|
|
216 | junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) ) | |
|
|
221 | 217 | except: |
|
|
222 | 218 | print "The read block (%3d) has not enough data" %self.nReadBlocks |
|
|
223 | 219 | return 0 |
|
|
224 | 220 | |
|
|
225 | 221 | junk = numpy.transpose(junk, (2,0,1)) |
|
|
226 | 222 | self.datablock = junk['real'] + junk['imag']*1j |
|
|
227 | 223 | |
|
|
228 | 224 | self.profileIndex = 0 |
|
|
229 | 225 | |
|
|
230 | 226 | self.flagIsNewFile = 0 |
|
|
231 | 227 | self.flagIsNewBlock = 1 |
|
|
232 | 228 | |
|
|
233 | 229 | self.nTotalBlocks += 1 |
|
|
234 | 230 | self.nReadBlocks += 1 |
|
|
235 | 231 | |
|
|
236 | 232 | return 1 |
|
|
237 | 233 | |
|
|
238 | 234 | |
|
|
239 | 235 | def getData(self): |
|
|
240 | 236 | """ |
|
|
241 | 237 | getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage" |
|
|
242 | 238 | con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de |
|
|
243 | 239 | lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock" |
|
|
244 | 240 | |
|
|
245 | 241 | Ademas incrementa el contador del buffer en 1. |
|
|
246 | 242 | |
|
|
247 | 243 | Return: |
|
|
248 | 244 | data : retorna un perfil de voltages (alturas * canales) copiados desde el |
|
|
249 | 245 | buffer. Si no hay mas archivos a leer retorna None. |
|
|
250 | 246 | |
|
|
251 | 247 | Variables afectadas: |
|
|
252 | 248 | self.dataOutObj |
|
|
253 | 249 | self.profileIndex |
|
|
254 | 250 | |
|
|
255 | 251 | Affected: |
|
|
256 | 252 | self.dataOutObj |
|
|
257 | 253 | self.profileIndex |
|
|
258 | 254 | self.flagTimeBlock |
|
|
259 | 255 | self.flagIsNewBlock |
|
|
260 | 256 | """ |
|
|
261 | 257 | if self.flagNoMoreFiles: return 0 |
|
|
262 | 258 | |
|
|
263 | 259 | self.flagTimeBlock = 0 |
|
|
264 | 260 | self.flagIsNewBlock = 0 |
|
|
265 | 261 | |
|
|
266 | 262 | if self.__hasNotDataInBuffer(): |
|
|
267 | 263 | |
|
|
268 | 264 | if not( self.readNextBlock() ): |
|
|
269 | 265 | return 0 |
|
|
270 | 266 | |
|
|
271 | self.updateDataHeader() | |
|
|
267 | # self.updateDataHeader() | |
|
|
272 | 268 | |
|
|
273 | 269 | if self.flagNoMoreFiles == 1: |
|
|
274 | 270 | print 'Process finished' |
|
|
275 | 271 | return 0 |
|
|
276 | 272 | |
|
|
277 | 273 | #data es un numpy array de 3 dmensiones (perfiles, alturas y canales) |
|
|
278 | 274 | |
|
|
279 | 275 | if self.datablock == None: |
|
|
280 | 276 | self.dataOutObj.flagNoData = True |
|
|
281 | 277 | return 0 |
|
|
282 | 278 | |
|
|
283 | 279 | self.dataOutObj.data = self.datablock[:,self.profileIndex,:] |
|
|
284 | 280 | |
|
|
285 | 281 | self.dataOutObj.dtype = self.dtype |
|
|
286 | 282 | |
|
|
287 |
self.dataOutObj.nChannels = self.systemHeaderObj.n |
|
|
|
283 | self.dataOutObj.nChannels = self.systemHeaderObj.nChannels | |
|
|
288 | 284 | |
|
|
289 |
self.dataOutObj.nHeights = self.processingHeaderObj.n |
|
|
|
285 | self.dataOutObj.nHeights = self.processingHeaderObj.nHeights | |
|
|
290 | 286 | |
|
|
291 | 287 | self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock |
|
|
292 | 288 | |
|
|
293 |
xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.n |
|
|
|
289 | xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight | |
|
|
294 | 290 | |
|
|
295 | self.dataOutObj.heightList = range(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight) | |
|
|
291 | self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight) | |
|
|
296 | 292 | |
|
|
297 |
self.dataOutObj.channelList = range(self.systemHeaderObj.n |
|
|
|
293 | self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels) | |
|
|
298 | 294 | |
|
|
299 |
self.dataOutObj.channelIndexList = range(self.systemHeaderObj.n |
|
|
|
295 | self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels) | |
|
|
300 | 296 | |
|
|
301 | 297 | self.dataOutObj.flagNoData = True |
|
|
302 | 298 | |
|
|
303 | 299 | self.dataOutObj.flagTimeBlock = self.flagTimeBlock |
|
|
304 | 300 | |
|
|
305 | 301 | self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc + self.profileIndex * self.ippSeconds |
|
|
306 | 302 | |
|
|
307 | 303 | self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt |
|
|
308 | 304 | |
|
|
309 | 305 | self.profileIndex += 1 |
|
|
310 | 306 | |
|
|
311 | 307 | self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy() |
|
|
312 | 308 | |
|
|
313 | 309 | self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy() |
|
|
314 | 310 | |
|
|
315 | 311 | return 1 |
|
|
316 | 312 | |
|
|
317 | 313 | |
|
|
318 | 314 | class VoltageWriter(JRODataWriter): |
|
|
319 | 315 | """ |
|
|
320 | 316 | Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura |
|
|
321 | 317 | de los datos siempre se realiza por bloques. |
|
|
322 | 318 | """ |
|
|
323 | 319 | __configHeaderFile = 'wrSetHeadet.txt' |
|
|
324 | 320 | |
|
|
325 | 321 | dataOutObj = None |
|
|
326 | 322 | |
|
|
327 | 323 | ext = ".r" |
|
|
328 | 324 | |
|
|
329 | 325 | optchar = "D" |
|
|
330 | 326 | |
|
|
331 | 327 | datablock = None |
|
|
332 | 328 | |
|
|
333 | 329 | profileIndex = 0 |
|
|
334 | 330 | |
|
|
335 | 331 | shapeBuffer = None |
|
|
336 | 332 | |
|
|
337 | 333 | |
|
|
338 | 334 | def __init__(self, dataOutObj=None): |
|
|
339 | 335 | """ |
|
|
340 | 336 | Inicializador de la clase VoltageWriter para la escritura de datos de espectros. |
|
|
341 | 337 | |
|
|
342 | 338 | Affected: |
|
|
343 | 339 | self.dataOutObj |
|
|
344 | 340 | |
|
|
345 | 341 | Return: None |
|
|
346 | 342 | """ |
|
|
347 | 343 | if dataOutObj == None: |
|
|
348 | 344 | dataOutObj = Voltage() |
|
|
349 | 345 | |
|
|
350 | 346 | if not( isinstance(dataOutObj, Voltage) ): |
|
|
351 | 347 | raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object" |
|
|
352 | 348 | |
|
|
353 | 349 | self.dataOutObj = dataOutObj |
|
|
354 | 350 | |
|
|
355 | 351 | |
|
|
356 | 352 | def hasAllDataInBuffer(self): |
|
|
357 | 353 | if self.profileIndex >= self.processingHeaderObj.profilesPerBlock: |
|
|
358 | 354 | return 1 |
|
|
359 | 355 | return 0 |
|
|
360 | 356 | |
|
|
361 | 357 | |
|
|
362 | 358 | def setBlockDimension(self): |
|
|
363 | 359 | """ |
|
|
364 | 360 | Obtiene las formas dimensionales del los subbloques de datos que componen un bloque |
|
|
365 | 361 | |
|
|
366 | 362 | Affected: |
|
|
367 | 363 | self.shape_spc_Buffer |
|
|
368 | 364 | self.shape_cspc_Buffer |
|
|
369 | 365 | self.shape_dc_Buffer |
|
|
370 | 366 | |
|
|
371 | 367 | Return: None |
|
|
372 | 368 | """ |
|
|
373 | 369 | self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock, |
|
|
374 |
self.processingHeaderObj.n |
|
|
|
375 |
self.systemHeaderObj.n |
|
|
|
370 | self.processingHeaderObj.nHeights, | |
|
|
371 | self.systemHeaderObj.nChannels ) | |
|
|
376 | 372 | |
|
|
377 |
self.datablock = numpy.zeros((self.systemHeaderObj.n |
|
|
|
373 | self.datablock = numpy.zeros((self.systemHeaderObj.nChannels, | |
|
|
378 | 374 | self.processingHeaderObj.profilesPerBlock, |
|
|
379 |
self.processingHeaderObj.n |
|
|
|
375 | self.processingHeaderObj.nHeights), | |
|
|
380 | 376 | dtype=numpy.dtype('complex')) |
|
|
381 | 377 | |
|
|
382 | 378 | |
|
|
383 | 379 | def writeBlock(self): |
|
|
384 | 380 | """ |
|
|
385 | 381 | Escribe el buffer en el file designado |
|
|
386 | 382 | |
|
|
387 | 383 | Affected: |
|
|
388 | 384 | self.profileIndex |
|
|
389 | 385 | self.flagIsNewFile |
|
|
390 | 386 | self.flagIsNewBlock |
|
|
391 | 387 | self.nTotalBlocks |
|
|
392 | 388 | self.blockIndex |
|
|
393 | 389 | |
|
|
394 | 390 | Return: None |
|
|
395 | 391 | """ |
|
|
396 | 392 | data = numpy.zeros( self.shapeBuffer, self.dtype ) |
|
|
397 | 393 | |
|
|
398 | 394 | junk = numpy.transpose(self.datablock, (1,2,0)) |
|
|
399 | 395 | |
|
|
400 | 396 | data['real'] = junk.real |
|
|
401 | 397 | data['imag'] = junk.imag |
|
|
402 | 398 | |
|
|
403 | 399 | data = data.reshape( (-1) ) |
|
|
404 | 400 | |
|
|
405 | 401 | data.tofile( self.fp ) |
|
|
406 | 402 | |
|
|
407 | 403 | self.datablock.fill(0) |
|
|
408 | 404 | |
|
|
409 | 405 | self.profileIndex = 0 |
|
|
410 | 406 | self.flagIsNewFile = 0 |
|
|
411 | 407 | self.flagIsNewBlock = 1 |
|
|
412 | 408 | |
|
|
413 | 409 | self.blockIndex += 1 |
|
|
414 | 410 | self.nTotalBlocks += 1 |
|
|
415 | 411 | |
|
|
416 | 412 | def putData(self): |
|
|
417 | 413 | """ |
|
|
418 | 414 | Setea un bloque de datos y luego los escribe en un file |
|
|
419 | 415 | |
|
|
420 | 416 | Affected: |
|
|
421 | 417 | self.flagIsNewBlock |
|
|
422 | 418 | self.profileIndex |
|
|
423 | 419 | |
|
|
424 | 420 | Return: |
|
|
425 | 421 | 0 : Si no hay data o no hay mas files que puedan escribirse |
|
|
426 | 422 | 1 : Si se escribio la data de un bloque en un file |
|
|
427 | 423 | """ |
|
|
428 | 424 | self.flagIsNewBlock = 0 |
|
|
429 | 425 | |
|
|
430 | 426 | if self.dataOutObj.flagNoData: |
|
|
431 | 427 | return 0 |
|
|
432 | 428 | |
|
|
433 | 429 | if self.dataOutObj.flagTimeBlock: |
|
|
434 | 430 | |
|
|
435 | 431 | self.datablock.fill(0) |
|
|
436 | 432 | self.profileIndex = 0 |
|
|
437 | 433 | self.setNextFile() |
|
|
438 | 434 | |
|
|
439 | 435 | self.datablock[:,self.profileIndex,:] = self.dataOutObj.data |
|
|
440 | 436 | |
|
|
441 | 437 | self.profileIndex += 1 |
|
|
442 | 438 | |
|
|
443 | 439 | if self.hasAllDataInBuffer(): |
|
|
444 | 440 | #if self.flagIsNewFile: |
|
|
445 | 441 | self.getDataHeader() |
|
|
446 | 442 | self.writeNextBlock() |
|
|
447 | 443 | |
|
|
448 | 444 | if self.flagNoMoreFiles: |
|
|
449 | 445 | #print 'Process finished' |
|
|
450 | 446 | return 0 |
|
|
451 | 447 | |
|
|
452 | 448 | return 1 |
|
|
453 | 449 | |
|
|
454 | 450 | def getDataHeader(self): |
|
|
455 | 451 | |
|
|
456 | 452 | """ |
|
|
457 | 453 | Obtiene una copia del First Header |
|
|
458 | 454 | |
|
|
459 | 455 | Affected: |
|
|
460 | 456 | self.systemHeaderObj |
|
|
461 | 457 | self.radarControllerHeaderObj |
|
|
462 | 458 | self.dtype |
|
|
463 | 459 | |
|
|
464 | 460 | Return: |
|
|
465 | 461 | None |
|
|
466 | 462 | """ |
|
|
467 | 463 | |
|
|
468 | 464 | # CALCULAR PARAMETROS |
|
|
469 | 465 | |
|
|
470 | 466 | self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy() |
|
|
471 | 467 | self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy() |
|
|
472 | 468 | |
|
|
473 | 469 | self.basicHeaderObj.size = self.basicHeaderSize |
|
|
474 | 470 | self.basicHeaderObj.version = self.versionFile |
|
|
475 | 471 | self.basicHeaderObj.dataBlock = self.nTotalBlocks |
|
|
476 | 472 | self.basicHeaderObj.utc = self.dataOutObj.dataUtcTime |
|
|
477 | 473 | self.basicHeaderObj.miliSecond = 0 |
|
|
478 | 474 | self.basicHeaderObj.timeZone = 0 |
|
|
479 | 475 | self.basicHeaderObj.dstFlag = 0 |
|
|
480 | 476 | self.basicHeaderObj.errorCount = 0 |
|
|
481 | 477 | |
|
|
482 | 478 | self.processingHeaderObj.size = 0 |
|
|
483 | 479 | self.processingHeaderObj.dtype = self.dataOutObj.dtype |
|
|
484 | 480 | self.processingHeaderObj.blockSize = 0 |
|
|
485 | 481 | self.processingHeaderObj.profilesPerBlock = 0 |
|
|
486 | 482 | self.processingHeaderObj.dataBlocksPerFile = 0 |
|
|
487 | 483 | self.processingHeaderObj.numWindows = 0 |
|
|
488 | 484 | self.processingHeaderObj.processFlags = 0 |
|
|
489 | 485 | self.processingHeaderObj.coherentInt = 0 |
|
|
490 | 486 | self.processingHeaderObj.incoherentInt = 0 |
|
|
491 | 487 | self.processingHeaderObj.totalSpectra = 0 |
|
|
492 | 488 | |
|
|
493 | 489 | self.dtype = self.dataOutObj.dtype |
|
|
494 | 490 | No newline at end of file |
| @@ -1,65 +1,65 | |||
|
|
1 | 1 | |
|
|
2 | 2 | import os, sys |
|
|
3 | 3 | import time, datetime |
|
|
4 | 4 | |
|
|
5 | 5 | path = os.path.split(os.getcwd())[0] |
|
|
6 | 6 | sys.path.append(path) |
|
|
7 | 7 | |
|
|
8 | 8 | from Data.Voltage import Voltage |
|
|
9 | 9 | from IO.VoltageIO import * |
|
|
10 | 10 | |
|
|
11 | 11 | from Processing.VoltageProcessor import * |
|
|
12 | 12 | |
|
|
13 | 13 | |
|
|
14 | 14 | |
|
|
15 | 15 | class TestSChain(): |
|
|
16 | 16 | |
|
|
17 | 17 | def __init__(self): |
|
|
18 | 18 | self.setValues() |
|
|
19 | 19 | self.createObjects() |
|
|
20 | 20 | self.testSChain() |
|
|
21 | 21 | |
|
|
22 | 22 | def setValues(self): |
|
|
23 | 23 | self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST" |
|
|
24 | self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING" | |
|
|
24 | # self.path = "/home/roj-idl71/Data/RAWDATA/IMAGING" | |
|
|
25 | 25 | |
|
|
26 | 26 | self.wrpath = "/Users/jro/Documents/RadarData/wr_data" |
|
|
27 | 27 | |
|
|
28 | 28 | self.startDate = datetime.date(2009,1,17) |
|
|
29 | 29 | self.endDate = datetime.date(2009,1,17) |
|
|
30 | 30 | |
|
|
31 | 31 | self.startTime = datetime.time(0,0,0) |
|
|
32 | 32 | self.endTime = datetime.time(14,1,1) |
|
|
33 | 33 | |
|
|
34 | 34 | def createObjects(self): |
|
|
35 | 35 | |
|
|
36 | 36 | self.readerObj = VoltageReader() |
|
|
37 | 37 | |
|
|
38 | 38 | self.voltObj1 = self.readerObj.setup( |
|
|
39 | 39 | path = self.path, |
|
|
40 | 40 | startDate = self.startDate, |
|
|
41 | 41 | endDate = self.endDate, |
|
|
42 | 42 | startTime = self.startTime, |
|
|
43 | 43 | endTime = self.endTime, |
|
|
44 | 44 | expLabel = '', |
|
|
45 | 45 | online = 0) |
|
|
46 | 46 | |
|
|
47 | 47 | |
|
|
48 | 48 | |
|
|
49 | 49 | def testSChain(self): |
|
|
50 | 50 | |
|
|
51 | 51 | ini = time.time() |
|
|
52 | 52 | |
|
|
53 | 53 | while(True): |
|
|
54 | 54 | self.readerObj.getData() |
|
|
55 | 55 | |
|
|
56 | 56 | if self.readerObj.flagNoMoreFiles: |
|
|
57 | 57 | break |
|
|
58 | 58 | |
|
|
59 | 59 | if self.readerObj.flagIsNewBlock: |
|
|
60 | 60 | print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks, |
|
|
61 |
datetime.datetime.fromtimestamp(self.readerObj. |
|
|
|
61 | datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),) | |
|
|
62 | 62 | |
|
|
63 | 63 | |
|
|
64 | 64 | if __name__ == '__main__': |
|
|
65 | 65 | TestSChain() No newline at end of file |
General Comments 0
You need to be logged in to leave comments.
Login now