##// END OF EJS Templates
schain-jc
RSS
IO:...
Victor Sarmiento -
r59:4a1c54fb9a59
parent child
Show More
Show file before | Show file after | Hide comments
@@ -29,6 +29,10 class SpectraReader( JRODataReader ):
29 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
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.
30 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
31
31
32 pares * alturas * perfiles (Self Spectra)
33 canales * alturas * perfiles (Cross Spectra)
34 canales * alturas (DC Channels)
35
32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
36 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
33 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
37 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
34 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
38 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
@@ -51,13 +55,28 class SpectraReader( JRODataReader ):
51
55
52 print readerObj.m_Spectra.data
56 print readerObj.m_Spectra.data
53
57
54 if readerObj.noMoreFiles:
58 if readerObj.flagNoMoreFiles:
55 break
59 break
56
60
57 """
61 """
62 m_DataObj = None
63
64 data_spc = None
65 data_cspc = None
66 data_dc = None
67
68 nChannels = 0
69
70 nPairs = 0
58
71
72 pts2read_SelfSpectra = 0
73 pts2read_CrossSpectra = 0
74 pts2read_DCchannels = 0
59
75
60 def __init__(self,m_Spectra=None):
76 ext = ".pdata"
77
78
79 def __init__(self, m_Spectra=None):
61 """
80 """
62 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
81 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
63
82
@@ -71,10 +90,6 class SpectraReader( JRODataReader ):
71
90
72 Affected:
91 Affected:
73 self.m_DataObj
92 self.m_DataObj
74 self.m_BasicHeader
75 self.m_SystemHeader
76 self.m_RadarControllerHeader
77 self.m_ProcessingHeader
78
93
79 Return : None
94 Return : None
80 """
95 """
@@ -83,95 +98,31 class SpectraReader( JRODataReader ):
83
98
84 if not( isinstance(m_Spectra, Spectra) ):
99 if not( isinstance(m_Spectra, Spectra) ):
85 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
100 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
86
87 self.m_DataObj = m_Spectra
88
89 self.m_BasicHeader = BasicHeader()
90
91 self.m_SystemHeader = SystemHeader()
92
93 self.m_RadarControllerHeader = RadarControllerHeader()
94
95 self.m_ProcessingHeader = ProcessingHeader()
96
97 self.fp = None
98
99 self.idFile = None
100
101 self.startDateTime = None
102
103 self.endDateTime = None
104
105 self.dataType = None
106
107 self.fileSizeByHeader = 0
108
109 self.pathList = []
110
111 self.filenameList = []
112
113 self.lastUTTime = 0
114
115 self.maxTimeStep = 30
116
117 self.flagIsNewFile = 0
118
119 self.flagResetProcessing = 0
120
121 self.flagIsNewBlock = 0
122
123 self.noMoreFiles = 0
124
125 self.nReadBlocks = 0
126
127 self.online = 0
128
129 self.firstHeaderSize = 0
130
131 self.basicHeaderSize = 24
132
133 self.filename = None
134
135 self.fileSize = None
136
137 self.data_spc = None
138 self.data_cspc = None
139 self.data_dc = None
140
101
141 self.nChannels = 0
102 self.m_DataObj = m_Spectra
142 self.nPairs = 0
143
144 self.pts2read_SelfSpectra = 0
145 self.pts2read_CrossSpectra = 0
146 self.pts2read_DCchannels = 0
147 self.blocksize = 0
148
149 self.datablockIndex = 0
150
151 self.ippSeconds = 0
152
153 self.nSelfChannels = 0
154
155 self.nCrossPairs = 0
156
157 self.datablock_id = 9999
158
103
159 self.delay = 2 #seconds
160 self.nTries = 3 #quantity tries
161 self.nFiles = 3 #number of files for searching
162 self.year = 0
163 self.doy = 0
164 self.set = 0
165 self.ext = ".pdata"
166 self.path = None
167 self.optchar = "P"
168 self.nBlocks = 0
169
104
170 def hasNotDataInBuffer(self):
105 def __hasNotDataInBuffer(self):
171 return 1
106 return 1
172
107
108
173 def getBlockDimension(self):
109 def getBlockDimension(self):
110 """
111 Obtiene la cantidad de puntos a leer por cada bloque de datos
174
112
113 Affected:
114 self.nChannels
115 self.nPairs
116 self.pts2read_SelfSpectra
117 self.pts2read_CrossSpectra
118 self.pts2read_DCchannels
119 self.blocksize
120 self.m_DataObj.nChannels
121 self.m_DataObj.nPairs
122
123 Return:
124 None
125 """
175 self.nChannels = 0
126 self.nChannels = 0
176 self.nPairs = 0
127 self.nPairs = 0
177
128
@@ -190,6 +141,7 class SpectraReader( JRODataReader ):
190
141
191 self.m_DataObj.nChannels = self.nChannels
142 self.m_DataObj.nChannels = self.nChannels
192 self.m_DataObj.nPairs = self.nPairs
143 self.m_DataObj.nPairs = self.nPairs
144
193
145
194 def readBlock(self):
146 def readBlock(self):
195 """
147 """
@@ -212,10 +164,6 class SpectraReader( JRODataReader ):
212 Exceptions:
164 Exceptions:
213 Si un bloque leido no es un bloque valido
165 Si un bloque leido no es un bloque valido
214 """
166 """
215 #self.datablock_id = 0
216 #self.flagIsNewFile = 0
217 #self.flagIsNewBlock = 1
218
219 blockOk_flag = False
167 blockOk_flag = False
220 fpointer = self.fp.tell()
168 fpointer = self.fp.tell()
221
169
@@ -226,10 +174,7 class SpectraReader( JRODataReader ):
226 if self.online:
174 if self.online:
227 if (spc.size + cspc.size + dc.size) != self.blocksize:
175 if (spc.size + cspc.size + dc.size) != self.blocksize:
228 for nTries in range( self.nTries ):
176 for nTries in range( self.nTries ):
229 #nTries = 0
177 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
230 #while( nTries < self.nTries ):
231 #nTries += 1
232 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
233 time.sleep( self.delay )
178 time.sleep( self.delay )
234 self.fp.seek( fpointer )
179 self.fp.seek( fpointer )
235 fpointer = self.fp.tell()
180 fpointer = self.fp.tell()
@@ -240,13 +185,8 class SpectraReader( JRODataReader ):
240 if (spc.size + cspc.size + dc.size) == self.blocksize:
185 if (spc.size + cspc.size + dc.size) == self.blocksize:
241 blockOk_flag = True
186 blockOk_flag = True
242 break
187 break
243 #if (spc.size + cspc.size + dc.size) == self.blocksize:
244 # nTries = 0
245 # break
246 if not( blockOk_flag ):
188 if not( blockOk_flag ):
247 return 0
189 return 0
248 #if nTries > 0:
249 # return 0
250
190
251 try:
191 try:
252 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
192 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
@@ -268,7 +208,7 class SpectraReader( JRODataReader ):
268 self.data_cspc = cspc['real'] + cspc['imag']*1j
208 self.data_cspc = cspc['real'] + cspc['imag']*1j
269 self.data_dc = dc['real'] + dc['imag']*1j
209 self.data_dc = dc['real'] + dc['imag']*1j
270
210
271 self.datablock_id = 0
211 self.datablockIndex = 0
272 self.flagIsNewFile = 0
212 self.flagIsNewFile = 0
273 self.flagIsNewBlock = 1
213 self.flagIsNewBlock = 1
274
214
@@ -277,6 +217,7 class SpectraReader( JRODataReader ):
277
217
278 return 1
218 return 1
279
219
220
280 def getData(self):
221 def getData(self):
281 """
222 """
282 Copia el buffer de lectura a la clase "Spectra",
223 Copia el buffer de lectura a la clase "Spectra",
@@ -294,10 +235,12 class SpectraReader( JRODataReader ):
294 self.flagIsNewBlock
235 self.flagIsNewBlock
295 """
236 """
296
237
238 if self.flagNoMoreFiles: return 0
239
297 self.flagResetProcessing = 0
240 self.flagResetProcessing = 0
298 self.flagIsNewBlock = 0
241 self.flagIsNewBlock = 0
299
242
300 if self.hasNotDataInBuffer():
243 if self.__hasNotDataInBuffer():
301
244
302 if not( self.readNextBlock() ):
245 if not( self.readNextBlock() ):
303 self.setNextFile()
246 self.setNextFile()
@@ -310,14 +253,14 class SpectraReader( JRODataReader ):
310 self.m_DataObj.heights = self.heights
253 self.m_DataObj.heights = self.heights
311 self.m_DataObj.dataType = self.dataType
254 self.m_DataObj.dataType = self.dataType
312
255
313 if self.noMoreFiles == 1:
256 if self.flagNoMoreFiles == 1:
314 print 'Process finished'
257 print 'Process finished'
315 return 0
258 return 0
316
259
317 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
260 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
318
261
319 if self.data_dc == None:
262 if self.data_dc == None:
320 self.m_Voltage.flagNoData = True
263 self.m_DataObj.flagNoData = True
321 return 0
264 return 0
322
265
323 self.m_DataObj.flagNoData = False
266 self.m_DataObj.flagNoData = False
@@ -328,18 +271,31 class SpectraReader( JRODataReader ):
328 self.m_DataObj.data_dc = self.data_dc
271 self.m_DataObj.data_dc = self.data_dc
329
272
330 #call setData - to Data Object
273 #call setData - to Data Object
331 #self.datablock_id += 1
274 #self.datablockIndex += 1
332 #self.idProfile += 1
275 #self.idProfile += 1
333
276
334 return 1
277 return 1
335
278
336 class SpectraWriter( JRODataWriter ):
279
280 class SpectraWriter(JRODataWriter):
281
337 """
282 """
338 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
283 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
339 de los datos siempre se realiza por bloques.
284 de los datos siempre se realiza por bloques.
340 """
285 """
341
286
342 def __init__(self,m_Spectra=None):
287 m_DataObj = None
288
289 ext = ".pdata"
290
291 optchar = "P"
292
293 shape_spc_Buffer = None
294 shape_cspc_Buffer = None
295 shape_dc_Buffer = None
296
297
298 def __init__(self, m_Spectra=None):
343 """
299 """
344 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
300 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
345
301
@@ -352,59 +308,30 class SpectraWriter( JRODataWriter ):
352
308
353 Return: None
309 Return: None
354 """
310 """
355
356 if m_Spectra == None:
311 if m_Spectra == None:
357 m_Spectra = Spectra()
312 m_Spectra = Spectra()
358
313
314 if not( isinstance(m_Spectra, Spectra) ):
315 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
316
359 self.m_DataObj = m_Spectra
317 self.m_DataObj = m_Spectra
360
361 self.fp = None
362
363 self.format = None
364
365 self.blocksCounter = 0
366
367 self.setFile = None
368
369 self.flagIsNewFile = 1
370
371 self.dataType = None
372
373 self.ext = ".pdata"
374
375 self.path = None
376
377 self.optchar = "P"
378
379 self.shape_spc_Buffer = None
380 self.shape_cspc_Buffer = None
381 self.shape_dc_Buffer = None
382
383 self.nWriteBlocks = 0
384
385 self.flagIsNewBlock = 0
386
387 self.noMoreFiles = 0
388
389 self.filename = None
390
391 self.m_BasicHeader= BasicHeader()
392
393 self.m_SystemHeader = SystemHeader()
394
395 self.m_RadarControllerHeader = RadarControllerHeader()
396
397 self.m_ProcessingHeader = ProcessingHeader()
398
399 self.data_spc = None
400 self.data_cspc = None
401 self.data_dc = None
402
318
319
403 def hasAllDataInBuffer(self):
320 def hasAllDataInBuffer(self):
404 return 1
321 return 1
322
405
323
406 def setBlockDimension(self):
324 def setBlockDimension(self):
325 """
326 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
327
328 Affected:
329 self.shape_spc_Buffer
330 self.shape_cspc_Buffer
331 self.shape_dc_Buffer
407
332
333 Return: None
334 """
408 self.shape_spc_Buffer = (self.m_DataObj.nChannels,
335 self.shape_spc_Buffer = (self.m_DataObj.nChannels,
409 self.m_ProcessingHeader.numHeights,
336 self.m_ProcessingHeader.numHeights,
410 self.m_ProcessingHeader.profilesPerBlock)
337 self.m_ProcessingHeader.profilesPerBlock)
@@ -463,6 +390,7 class SpectraWriter( JRODataWriter ):
463 self.nWriteBlocks += 1
390 self.nWriteBlocks += 1
464 self.blocksCounter += 1
391 self.blocksCounter += 1
465
392
393
466 def putData(self):
394 def putData(self):
467 """
395 """
468 Setea un bloque de datos y luego los escribe en un file
396 Setea un bloque de datos y luego los escribe en un file
@@ -491,11 +419,12 class SpectraWriter( JRODataWriter ):
491 self.data_cspc = self.m_DataObj.data_cspc
419 self.data_cspc = self.m_DataObj.data_cspc
492 self.data_dc = self.m_DataObj.data_dc
420 self.data_dc = self.m_DataObj.data_dc
493
421
422 # #self.m_ProcessingHeader.dataBlocksPerFile)
494 if True:
423 if True:
495 self.getHeader()
424 self.getHeader()
496 self.writeNextBlock()
425 self.writeNextBlock()
497
426
498 if self.noMoreFiles:
427 if self.flagNoMoreFiles:
499 #print 'Process finished'
428 #print 'Process finished'
500 return 0
429 return 0
501
430
Show file before | Show file after | Hide comments
@@ -20,12 +20,15 from Model.Voltage import Voltage
20 from IO.DataIO import JRODataReader
20 from IO.DataIO import JRODataReader
21 from IO.DataIO import JRODataWriter
21 from IO.DataIO import JRODataWriter
22
22
23
23 class VoltageReader(JRODataReader):
24 class VoltageReader(JRODataReader):
24 """
25 """
25 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
26 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
26 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
27 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
27 perfiles*alturas*canales) son almacenados en la variable "buffer".
28 perfiles*alturas*canales) son almacenados en la variable "buffer".
28
29
30 Voltajes - perfiles * alturas * canales
31
29 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
32 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
30 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
33 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
31 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
34 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
@@ -54,13 +57,24 class VoltageReader(JRODataReader):
54 #If you want to see all datablock
57 #If you want to see all datablock
55 print readerObj.datablock
58 print readerObj.datablock
56
59
57 if readerObj.noMoreFiles:
60 if readerObj.flagNoMoreFiles:
58 break
61 break
59
62
60 """
63 """
64 m_DataObj = None
65
66 idProfile = 0
67
68 datablock = None
69
70 ext = ".r"
71
72 pts2read = 0
73
74 utc = 0
61
75
62
76
63 def __init__(self,m_Voltage=None):
77 def __init__(self, m_Voltage=None):
64 """
78 """
65 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
79 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
66
80
@@ -74,15 +88,9 class VoltageReader(JRODataReader):
74
88
75 Variables afectadas:
89 Variables afectadas:
76 self.m_DataObj
90 self.m_DataObj
77 self.m_BasicHeader
78 self.m_SystemHeader
79 self.m_RadarControllerHeader
80 self.m_ProcessingHeader
81
82
91
83 Return:
92 Return:
84 Void
93 None
85
86 """
94 """
87 if m_Voltage == None:
95 if m_Voltage == None:
88 m_Voltage = Voltage()
96 m_Voltage = Voltage()
@@ -91,98 +99,28 class VoltageReader(JRODataReader):
91 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
99 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
92
100
93 self.m_DataObj = m_Voltage
101 self.m_DataObj = m_Voltage
94
95 self.m_BasicHeader = BasicHeader()
96
97 self.m_SystemHeader = SystemHeader()
98
99 self.m_RadarControllerHeader = RadarControllerHeader()
100
101 self.m_ProcessingHeader = ProcessingHeader()
102
103 self.fp = None
104
105 self.idFile = None
106
107 self.startDateTime = None
108
109 self.endDateTime = None
110
111 self.dataType = None
112
113 self.fileSizeByHeader = 0
114
115 self.pathList = []
116
117 self.filenameList = []
118
119 self.lastUTTime = 0
120
121 self.maxTimeStep = 30
122
123 self.flagIsNewFile = 0
124
125 self.ippSeconds = 0
126
127 self.flagResetProcessing = 0
128
129 self.flagIsNewBlock = 0
130
131 self.noMoreFiles = 0
132
133 self.nReadBlocks = 0
134
135 self.online = 0
136
137 self.filename = None
138
139 self.fileSize = None
140
141 self.firstHeaderSize = 0
142
143 self.basicHeaderSize = 24
144
145 self.idProfile = 0
146
147 self.datablock = None
148
149 self.datablockIndex = 9999
150
102
151 self.delay = 7 #seconds
152
153 self.nTries = 3 #quantity tries
154
155 self.nFiles = 3 #number of files for searching
156
157 self.year = 0
158
159 self.doy = 0
160
161 self.set = 0
162
163 self.ext = ".r"
164
165 self.path = None
166
167 self.optchar = "D"
168
169 self.pts2read = 0
170
171 self.blocksize = 0
172
173 self.utc = 0
174
175 self.nBlocks = 0
176
103
177 def hasNotDataInBuffer(self):
104 def __hasNotDataInBuffer(self):
178 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
105 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
179 return 1
106 return 1
180 return 0
107 return 0
181
108
109
182 def getBlockDimension(self):
110 def getBlockDimension(self):
111 """
112 Obtiene la cantidad de puntos a leer por cada bloque de datos
183
113
114 Affected:
115 self.pts2read
116 self.blocksize
117
118 Return:
119 None
120 """
184 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
121 self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
185 self.blocksize = self.pts2read
122 self.blocksize = self.pts2read
123
186
124
187 def readBlock(self):
125 def readBlock(self):
188 """
126 """
@@ -216,7 +154,7 class VoltageReader(JRODataReader):
216 if self.online:
154 if self.online:
217 if junk.size != self.blocksize:
155 if junk.size != self.blocksize:
218 for nTries in range( self.nTries ):
156 for nTries in range( self.nTries ):
219 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
157 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
220 time.sleep( self.delay )
158 time.sleep( self.delay )
221 self.fp.seek( fpointer )
159 self.fp.seek( fpointer )
222 fpointer = self.fp.tell()
160 fpointer = self.fp.tell()
@@ -246,6 +184,7 class VoltageReader(JRODataReader):
246 self.nBlocks += 1
184 self.nBlocks += 1
247
185
248 return 1
186 return 1
187
249
188
250 def getData(self):
189 def getData(self):
251 """
190 """
@@ -271,12 +210,12 class VoltageReader(JRODataReader):
271 self.flagIsNewBlock
210 self.flagIsNewBlock
272 self.idProfile
211 self.idProfile
273 """
212 """
274 if self.noMoreFiles: return 0
213 if self.flagNoMoreFiles: return 0
275
214
276 self.flagResetProcessing = 0
215 self.flagResetProcessing = 0
277 self.flagIsNewBlock = 0
216 self.flagIsNewBlock = 0
278
217
279 if self.hasNotDataInBuffer():
218 if self.__hasNotDataInBuffer():
280
219
281 if not( self.readNextBlock() ):
220 if not( self.readNextBlock() ):
282 self.setNextFile()
221 self.setNextFile()
@@ -289,7 +228,7 class VoltageReader(JRODataReader):
289 self.m_DataObj.heights = self.heights
228 self.m_DataObj.heights = self.heights
290 self.m_DataObj.dataType = self.dataType
229 self.m_DataObj.dataType = self.dataType
291
230
292 if self.noMoreFiles == 1:
231 if self.flagNoMoreFiles == 1:
293 print 'Process finished'
232 print 'Process finished'
294 return 0
233 return 0
295
234
@@ -316,6 +255,7 class VoltageReader(JRODataReader):
316
255
317 return 1 #self.m_DataObj.data
256 return 1 #self.m_DataObj.data
318
257
258
319 class VoltageWriter( JRODataWriter ):
259 class VoltageWriter( JRODataWriter ):
320 """
260 """
321 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
261 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
@@ -323,76 +263,60 class VoltageWriter( JRODataWriter ):
323 """
263 """
324 __configHeaderFile = 'wrSetHeadet.txt'
264 __configHeaderFile = 'wrSetHeadet.txt'
325
265
326 def __init__(self,m_Voltage=None):
266 m_DataObj = None
267
268 datablock = None
269
270 datablockIndex = 0
271
272 ext = ".r"
273
274 optchar = "D"
275
276 shapeBuffer = None
277
278
279 def __init__(self, m_Voltage=None):
327 """
280 """
328 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
281 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
329
282
330 Affected:
283 Affected:
331 self.m_DataObj
284 self.m_DataObj
332 self.m_BasicHeader
333 self.m_SystemHeader
334 self.m_RadarControllerHeader
335 self.m_ProcessingHeader
336
285
337 Return: None
286 Return: None
338 """
287 """
339 if m_Voltage == None:
288 if m_Voltage == None:
340 m_Voltage = Voltage()
289 m_Voltage = Voltage()
341
290
291 if not( isinstance(m_Voltage, Voltage) ):
292 raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
293
342 self.m_DataObj = m_Voltage
294 self.m_DataObj = m_Voltage
343
295
344 self.fp = None
345
346 self.format = None
347
348 self.blocksCounter = 0
349
350 self.setFile = None
351
352 self.flagIsNewFile = 1
353
354 self.datablock = None
355
356 self.datablockIndex = 0
357
358 self.dataType = None
359
360 self.ext = ".r"
361
362 self.path = None
363
364 self.optchar = "D"
365
366 self.shapeBuffer = None
367
368 self.nWriteBlocks = 0
369
370 self.flagIsNewBlock = 0
371
372 self.noMoreFiles = 0
373
374 self.filename = None
375
376 self.m_BasicHeader= BasicHeader()
377
378 self.m_SystemHeader = SystemHeader()
379
380 self.m_RadarControllerHeader = RadarControllerHeader()
381
382 self.m_ProcessingHeader = ProcessingHeader()
383
296
384 def hasAllDataInBuffer(self):
297 def hasAllDataInBuffer(self):
385 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
298 if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
386 return 1
299 return 1
387 return 0
300 return 0
388
301
302
389 def setBlockDimension(self):
303 def setBlockDimension(self):
390
304 """
391 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
305 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
392 self.m_ProcessingHeader.numHeights,
306
393 self.m_SystemHeader.numChannels )
307 Affected:
308 self.shape_spc_Buffer
309 self.shape_cspc_Buffer
310 self.shape_dc_Buffer
311
312 Return: None
313 """
314 self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
315 self.m_ProcessingHeader.numHeights,
316 self.m_SystemHeader.numChannels )
394
317
395 self.datablock = numpy.zeros(self.shapeBuffer, numpy.dtype('complex'))
318 self.datablock = numpy.zeros(self.shapeBuffer, numpy.dtype('complex'))
319
396
320
397 def writeBlock(self):
321 def writeBlock(self):
398 """
322 """
@@ -423,6 +347,7 class VoltageWriter( JRODataWriter ):
423 self.nWriteBlocks += 1
347 self.nWriteBlocks += 1
424 self.blocksCounter += 1
348 self.blocksCounter += 1
425
349
350
426 def putData(self):
351 def putData(self):
427 """
352 """
428 Setea un bloque de datos y luego los escribe en un file
353 Setea un bloque de datos y luego los escribe en un file
@@ -451,14 +376,13 class VoltageWriter( JRODataWriter ):
451 self.datablockIndex += 1
376 self.datablockIndex += 1
452
377
453 if self.hasAllDataInBuffer():
378 if self.hasAllDataInBuffer():
379 #if self.flagIsNewFile:
454 self.getHeader()
380 self.getHeader()
455 self.writeNextBlock()
381 self.writeNextBlock()
456
382
457 if self.noMoreFiles:
383 if self.flagNoMoreFiles:
458 #print 'Process finished'
384 #print 'Process finished'
459 return 0
385 return 0
460
386
461 return 1
387 return 1
462
463
464 No newline at end of file
388
General Comments 0
You need to be logged in to leave comments. Login now