##// END OF EJS Templates
schain-jc
RSS
Hasta el momento se realiza la lectura de Rawdata
Daniel Valdez -
r121:65ae6ea47e4e
parent child
Show More
Show file before | Show file after | Hide comments
@@ -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
Show file before | Show file after | Hide comments
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
Show file before | Show file after | Hide comments
@@ -46,7 +46,3 class Voltage(JROData):
46 46 self.dataUtcTime = None
47 47
48 48 self.nCohInt = None
49
50
51
52 No newline at end of file
Show file before | Show file after | Hide comments
@@ -11,6 +11,25 sys.path.append(path)
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.
@@ -108,6 +127,10 class JRODataIO:
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
@@ -237,7 +260,7 class JRODataReader(JRODataIO):
237 260
238 261 return None
239 262
240 self.updateDataHeader()
263 # self.updateDataHeader()
241 264
242 265 return self.dataOutObj
243 266
@@ -288,6 +311,43 class JRODataReader(JRODataIO):
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
Show file before | Show file after | Hide comments
@@ -189,7 +189,7 class RadarControllerHeader(Header):
189 189 self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
190 190
191 191 self.samplingWindow = None
192 self.numHeights = None
192 self.nHeights = None
193 193 self.firstHeight = None
194 194 self.deltaHeight = None
195 195 self.samplesWin = None
@@ -232,7 +232,7 class RadarControllerHeader(Header):
232 232 fp.seek(backFp)
233 233
234 234 self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
235 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
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']
@@ -336,7 +336,7 class ProcessingHeader(Header):
336 336 ])
337 337 self.samplingWindow = 0
338 338 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
339 self.numHeights = 0
339 self.nHeights = 0
340 340 self.firstHeight = 0
341 341 self.deltaHeight = 0
342 342 self.samplesWin = 0
@@ -362,9 +362,9 class ProcessingHeader(Header):
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.numHeights = numpy.sum(self.samplingWindow['nsa'])
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
Show file before | Show file after | Hide comments
@@ -110,10 +110,6 class VoltageReader(JRODataReader):
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
@@ -186,7 +182,7 class VoltageReader(JRODataReader):
186 182 Return:
187 183 None
188 184 """
189 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.numHeights * self.systemHeaderObj.numChannels
185 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
190 186 self.blocksize = pts2read
191 187
192 188
@@ -217,7 +213,7 class VoltageReader(JRODataReader):
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.numHeights, self.systemHeaderObj.numChannels) )
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
@@ -268,7 +264,7 class VoltageReader(JRODataReader):
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'
@@ -284,19 +280,19 class VoltageReader(JRODataReader):
284 280
285 281 self.dataOutObj.dtype = self.dtype
286 282
287 self.dataOutObj.nChannels = self.systemHeaderObj.numChannels
283 self.dataOutObj.nChannels = self.systemHeaderObj.nChannels
288 284
289 self.dataOutObj.nHeights = self.processingHeaderObj.numHeights
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.numHeights*self.processingHeaderObj.deltaHeight
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.numChannels)
293 self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
298 294
299 self.dataOutObj.channelIndexList = range(self.systemHeaderObj.numChannels)
295 self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
300 296
301 297 self.dataOutObj.flagNoData = True
302 298
@@ -371,12 +367,12 class VoltageWriter(JRODataWriter):
371 367 Return: None
372 368 """
373 369 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
374 self.processingHeaderObj.numHeights,
375 self.systemHeaderObj.numChannels )
370 self.processingHeaderObj.nHeights,
371 self.systemHeaderObj.nChannels )
376 372
377 self.datablock = numpy.zeros((self.systemHeaderObj.numChannels,
373 self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
378 374 self.processingHeaderObj.profilesPerBlock,
379 self.processingHeaderObj.numHeights),
375 self.processingHeaderObj.nHeights),
380 376 dtype=numpy.dtype('complex'))
381 377
382 378
Show file before | Show file after | Hide comments
@@ -21,7 +21,7 class 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
@@ -58,7 +58,7 class TestSChain():
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.m_BasicHeader.utc),)
61 datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
62 62
63 63
64 64 if __name__ == '__main__':
General Comments 0
You need to be logged in to leave comments. Login now