##// END OF EJS Templates
schain
RSS
En jrodata.py no se considera el factor para el caso del filtro en alturas, por el momento solo se realiza la suma de los valores sin ninguna division o normalizacion de este resultado, verficar en jroprocessing.py....
Daniel Valdez -
r268:43faa0eea275
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,552 +1,552
1 1 '''
2 2
3 3 $Author: murco $
4 4 $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
5 5 '''
6 6
7 7 import os, sys
8 8 import copy
9 9 import numpy
10 10 import datetime
11 11
12 12 from jroheaderIO import SystemHeader, RadarControllerHeader
13 13
14 14 def hildebrand_sekhon(data, navg):
15 15 """
16 16 This method is for the objective determination of de noise level in Doppler spectra. This
17 17 implementation technique is based on the fact that the standard deviation of the spectral
18 18 densities is equal to the mean spectral density for white Gaussian noise
19 19
20 20 Inputs:
21 21 Data : heights
22 22 navg : numbers of averages
23 23
24 24 Return:
25 25 -1 : any error
26 26 anoise : noise's level
27 27 """
28 28
29 29 dataflat = data.copy().reshape(-1)
30 30 dataflat.sort()
31 31 npts = dataflat.size #numbers of points of the data
32 32 npts_noise = 0.2*npts
33 33
34 34 if npts < 32:
35 35 print "error in noise - requires at least 32 points"
36 36 return -1.0
37 37
38 38 dataflat2 = numpy.power(dataflat,2)
39 39
40 40 cs = numpy.cumsum(dataflat)
41 41 cs2 = numpy.cumsum(dataflat2)
42 42
43 43 # data sorted in ascending order
44 44 nmin = int((npts + 7.)/8)
45 45
46 46 for i in range(nmin, npts):
47 47 s = cs[i]
48 48 s2 = cs2[i]
49 49 p = s / float(i);
50 50 p2 = p**2;
51 51 q = s2 / float(i) - p2;
52 52 leftc = p2;
53 53 rightc = q * float(navg);
54 54 R2 = leftc/rightc
55 55
56 56 # Signal detect: R2 < 1 (R2 = leftc/rightc)
57 57 if R2 < 1:
58 58 npts_noise = i
59 59 break
60 60
61 61
62 62 anoise = numpy.average(dataflat[0:npts_noise])
63 63
64 64 return anoise;
65 65
66 66 def sorting_bruce(data, navg):
67 67
68 68 data = data.copy()
69 69
70 70 sortdata = numpy.sort(data)
71 71 lenOfData = len(data)
72 72 nums_min = lenOfData/10
73 73
74 74 if (lenOfData/10) > 0:
75 75 nums_min = lenOfData/10
76 76 else:
77 77 nums_min = 0
78 78
79 79 rtest = 1.0 + 1.0/navg
80 80
81 81 sum = 0.
82 82
83 83 sumq = 0.
84 84
85 85 j = 0
86 86
87 87 cont = 1
88 88
89 89 while((cont==1)and(j<lenOfData)):
90 90
91 91 sum += sortdata[j]
92 92
93 93 sumq += sortdata[j]**2
94 94
95 95 j += 1
96 96
97 97 if j > nums_min:
98 98 if ((sumq*j) <= (rtest*sum**2)):
99 99 lnoise = sum / j
100 100 else:
101 101 j = j - 1
102 102 sum = sum - sordata[j]
103 103 sumq = sumq - sordata[j]**2
104 104 cont = 0
105 105
106 106 if j == nums_min:
107 107 lnoise = sum /j
108 108
109 109 return lnoise
110 110
111 111 class JROData:
112 112
113 113 # m_BasicHeader = BasicHeader()
114 114 # m_ProcessingHeader = ProcessingHeader()
115 115
116 116 systemHeaderObj = SystemHeader()
117 117
118 118 radarControllerHeaderObj = RadarControllerHeader()
119 119
120 120 # data = None
121 121
122 122 type = None
123 123
124 124 dtype = None
125 125
126 126 # nChannels = None
127 127
128 128 # nHeights = None
129 129
130 130 nProfiles = None
131 131
132 132 heightList = None
133 133
134 134 channelList = None
135 135
136 136 flagNoData = True
137 137
138 138 flagTimeBlock = False
139 139
140 140 utctime = None
141 141
142 142 blocksize = None
143 143
144 144 nCode = None
145 145
146 146 nBaud = None
147 147
148 148 code = None
149 149
150 150 flagDecodeData = False #asumo q la data no esta decodificada
151 151
152 152 flagDeflipData = False #asumo q la data no esta sin flip
153 153
154 154 flagShiftFFT = False
155 155
156 156 ippSeconds = None
157 157
158 158 timeInterval = None
159 159
160 160 nCohInt = None
161 161
162 162 noise = None
163 163
164 164 windowOfFilter = 1
165 165
166 166 #Speed of ligth
167 167 C = 3e8
168 168
169 169 frequency = 49.92e6
170 170
171 171 def __init__(self):
172 172
173 173 raise ValueError, "This class has not been implemented"
174 174
175 175 def copy(self, inputObj=None):
176 176
177 177 if inputObj == None:
178 178 return copy.deepcopy(self)
179 179
180 180 for key in inputObj.__dict__.keys():
181 181 self.__dict__[key] = inputObj.__dict__[key]
182 182
183 183 def deepcopy(self):
184 184
185 185 return copy.deepcopy(self)
186 186
187 187 def isEmpty(self):
188 188
189 189 return self.flagNoData
190 190
191 191 def getNoise(self):
192 192
193 193 raise ValueError, "Not implemented"
194 194
195 195 def getNChannels(self):
196 196
197 197 return len(self.channelList)
198 198
199 199 def getChannelIndexList(self):
200 200
201 201 return range(self.nChannels)
202 202
203 203 def getNHeights(self):
204 204
205 205 return len(self.heightList)
206 206
207 207 def getHeiRange(self, extrapoints=0):
208 208
209 209 heis = self.heightList
210 210 # deltah = self.heightList[1] - self.heightList[0]
211 211 #
212 212 # heis.append(self.heightList[-1])
213 213
214 214 return heis
215 215
216 216 def getDatatime(self):
217 217
218 218 datatime = datetime.datetime.utcfromtimestamp(self.utctime)
219 219 return datatime
220 220
221 221 def getTimeRange(self):
222 222
223 223 datatime = []
224 224
225 225 datatime.append(self.utctime)
226 226 datatime.append(self.utctime + self.timeInterval)
227 227
228 228 datatime = numpy.array(datatime)
229 229
230 230 return datatime
231 231
232 232 def getFmax(self):
233 233
234 234 PRF = 1./(self.ippSeconds * self.nCohInt)
235 235
236 236 fmax = PRF/2.
237 237
238 238 return fmax
239 239
240 240 def getVmax(self):
241 241
242 242 _lambda = self.C/self.frequency
243 243
244 244 vmax = self.getFmax() * _lambda
245 245
246 246 return vmax
247 247
248 248 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
249 249 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
250 250 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
251 251 noise = property(getNoise, "I'm the 'nHeights' property.")
252 252 datatime = property(getDatatime, "I'm the 'datatime' property")
253 253
254 254 class Voltage(JROData):
255 255
256 256 #data es un numpy array de 2 dmensiones (canales, alturas)
257 257 data = None
258 258
259 259 def __init__(self):
260 260 '''
261 261 Constructor
262 262 '''
263 263
264 264 self.radarControllerHeaderObj = RadarControllerHeader()
265 265
266 266 self.systemHeaderObj = SystemHeader()
267 267
268 268 self.type = "Voltage"
269 269
270 270 self.data = None
271 271
272 272 self.dtype = None
273 273
274 274 # self.nChannels = 0
275 275
276 276 # self.nHeights = 0
277 277
278 278 self.nProfiles = None
279 279
280 280 self.heightList = None
281 281
282 282 self.channelList = None
283 283
284 284 # self.channelIndexList = None
285 285
286 286 self.flagNoData = True
287 287
288 288 self.flagTimeBlock = False
289 289
290 290 self.utctime = None
291 291
292 292 self.nCohInt = None
293 293
294 294 self.blocksize = None
295 295
296 296 self.flagDecodeData = False #asumo q la data no esta decodificada
297 297
298 298 self.flagDeflipData = False #asumo q la data no esta sin flip
299 299
300 300 self.flagShiftFFT = False
301 301
302 302
303 303 def getNoisebyHildebrand(self):
304 304 """
305 305 Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
306 306
307 307 Return:
308 308 noiselevel
309 309 """
310 310
311 311 for channel in range(self.nChannels):
312 312 daux = self.data_spc[channel,:,:]
313 313 self.noise[channel] = hildebrand_sekhon(daux, self.nCohInt)
314 314
315 315 return self.noise
316 316
317 317 def getNoise(self, type = 1):
318 318
319 319 self.noise = numpy.zeros(self.nChannels)
320 320
321 321 if type == 1:
322 322 noise = self.getNoisebyHildebrand()
323 323
324 324 return 10*numpy.log10(noise)
325 325
326 326 class Spectra(JROData):
327 327
328 328 #data es un numpy array de 2 dmensiones (canales, perfiles, alturas)
329 329 data_spc = None
330 330
331 331 #data es un numpy array de 2 dmensiones (canales, pares, alturas)
332 332 data_cspc = None
333 333
334 334 #data es un numpy array de 2 dmensiones (canales, alturas)
335 335 data_dc = None
336 336
337 337 nFFTPoints = None
338 338
339 339 nPairs = None
340 340
341 341 pairsList = None
342 342
343 343 nIncohInt = None
344 344
345 345 wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia
346 346
347 347 nCohInt = None #se requiere para determinar el valor de timeInterval
348 348
349 349 def __init__(self):
350 350 '''
351 351 Constructor
352 352 '''
353 353
354 354 self.radarControllerHeaderObj = RadarControllerHeader()
355 355
356 356 self.systemHeaderObj = SystemHeader()
357 357
358 358 self.type = "Spectra"
359 359
360 360 # self.data = None
361 361
362 362 self.dtype = None
363 363
364 364 # self.nChannels = 0
365 365
366 366 # self.nHeights = 0
367 367
368 368 self.nProfiles = None
369 369
370 370 self.heightList = None
371 371
372 372 self.channelList = None
373 373
374 374 # self.channelIndexList = None
375 375
376 376 self.flagNoData = True
377 377
378 378 self.flagTimeBlock = False
379 379
380 380 self.utctime = None
381 381
382 382 self.nCohInt = None
383 383
384 384 self.nIncohInt = None
385 385
386 386 self.blocksize = None
387 387
388 388 self.nFFTPoints = None
389 389
390 390 self.wavelength = None
391 391
392 392 self.flagDecodeData = False #asumo q la data no esta decodificada
393 393
394 394 self.flagDeflipData = False #asumo q la data no esta sin flip
395 395
396 396 self.flagShiftFFT = False
397 397
398 398 def getNoisebyHildebrand(self):
399 399 """
400 400 Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
401 401
402 402 Return:
403 403 noiselevel
404 404 """
405 405
406 406 for channel in range(self.nChannels):
407 407 daux = self.data_spc[channel,:,:]
408 408 self.noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
409 409
410 410 return self.noise
411 411
412 412 def getNoisebyWindow(self, heiIndexMin=0, heiIndexMax=-1, freqIndexMin=0, freqIndexMax=-1):
413 413 """
414 414 Determina el ruido del canal utilizando la ventana indicada con las coordenadas:
415 415 (heiIndexMIn, freqIndexMin) hasta (heiIndexMax, freqIndexMAx)
416 416
417 417 Inputs:
418 418 heiIndexMin: Limite inferior del eje de alturas
419 419 heiIndexMax: Limite superior del eje de alturas
420 420 freqIndexMin: Limite inferior del eje de frecuencia
421 421 freqIndexMax: Limite supoerior del eje de frecuencia
422 422 """
423 423
424 424 data = self.data_spc[:, heiIndexMin:heiIndexMax, freqIndexMin:freqIndexMax]
425 425
426 426 for channel in range(self.nChannels):
427 427 daux = data[channel,:,:]
428 428 self.noise[channel] = numpy.average(daux)
429 429
430 430 return self.noise
431 431
432 432 def getNoisebySort(self):
433 433
434 434 for channel in range(self.nChannels):
435 435 daux = self.data_spc[channel,:,:]
436 436 self.noise[channel] = sorting_bruce(daux, self.nIncohInt)
437 437
438 438 return self.noise
439 439
440 440 def getNoise(self, type = 1):
441 441
442 442 self.noise = numpy.zeros(self.nChannels)
443 443
444 444 if type == 1:
445 445 noise = self.getNoisebyHildebrand()
446 446
447 447 if type == 2:
448 448 noise = self.getNoisebySort()
449 449
450 450 if type == 3:
451 451 noise = self.getNoisebyWindow()
452 452
453 453 return noise
454 454
455 455
456 456 def getFreqRange(self, extrapoints=0):
457 457
458 458 deltafreq = self.getFmax() / self.nFFTPoints
459 459 freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
460 460
461 461 return freqrange
462 462
463 463 def getVelRange(self, extrapoints=0):
464 464
465 465 deltav = self.getVmax() / self.nFFTPoints
466 466 velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltav/2
467 467
468 468 return velrange
469 469
470 470 def getNPairs(self):
471 471
472 472 return len(self.pairsList)
473 473
474 474 def getPairsIndexList(self):
475 475
476 476 return range(self.nPairs)
477 477
478 478 def getNormFactor(self):
479 479 pwcode = 1
480 480 if self.flagDecodeData:
481 481 pwcode = numpy.sum(self.code[0]**2)
482 normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*self.windowOfFilter*pwcode
482 normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode
483 483
484 484 return normFactor
485 485
486 486 def getFlagCspc(self):
487 487
488 488 if self.data_cspc == None:
489 489 return True
490 490
491 491 return False
492 492
493 493 def getFlagDc(self):
494 494
495 495 if self.data_dc == None:
496 496 return True
497 497
498 498 return False
499 499
500 500 nPairs = property(getNPairs, "I'm the 'nPairs' property.")
501 501 pairsIndexList = property(getPairsIndexList, "I'm the 'pairsIndexList' property.")
502 502 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
503 503 flag_cspc = property(getFlagCspc)
504 504 flag_dc = property(getFlagDc)
505 505
506 506 class SpectraHeis(JROData):
507 507
508 508 data_spc = None
509 509
510 510 data_cspc = None
511 511
512 512 data_dc = None
513 513
514 514 nFFTPoints = None
515 515
516 516 nPairs = None
517 517
518 518 pairsList = None
519 519
520 520 nIncohInt = None
521 521
522 522 def __init__(self):
523 523
524 524 self.radarControllerHeaderObj = RadarControllerHeader()
525 525
526 526 self.systemHeaderObj = SystemHeader()
527 527
528 528 self.type = "SpectraHeis"
529 529
530 530 self.dtype = None
531 531
532 532 # self.nChannels = 0
533 533
534 534 # self.nHeights = 0
535 535
536 536 self.nProfiles = None
537 537
538 538 self.heightList = None
539 539
540 540 self.channelList = None
541 541
542 542 # self.channelIndexList = None
543 543
544 544 self.flagNoData = True
545 545
546 546 self.flagTimeBlock = False
547 547
548 548 self.nPairs = 0
549 549
550 550 self.utctime = None
551 551
552 552 self.blocksize = None
Show file before | Show file after | Hide comments
@@ -1,2574 +1,2574
1 1 '''
2 2
3 3 $Author: murco $
4 4 $Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
5 5 '''
6 6
7 7 import os, sys
8 8 import glob
9 9 import time
10 10 import numpy
11 11 import fnmatch
12 12 import time, datetime
13 13
14 14 from jrodata import *
15 15 from jroheaderIO import *
16 16 from jroprocessing import *
17 17
18 18 LOCALTIME = -18000
19 19
20 20 def isNumber(str):
21 21 """
22 22 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
23 23
24 24 Excepciones:
25 25 Si un determinado string no puede ser convertido a numero
26 26 Input:
27 27 str, string al cual se le analiza para determinar si convertible a un numero o no
28 28
29 29 Return:
30 30 True : si el string es uno numerico
31 31 False : no es un string numerico
32 32 """
33 33 try:
34 34 float( str )
35 35 return True
36 36 except:
37 37 return False
38 38
39 39 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
40 40 """
41 41 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
42 42
43 43 Inputs:
44 44 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
45 45
46 46 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
47 47 segundos contados desde 01/01/1970.
48 48 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
49 49 segundos contados desde 01/01/1970.
50 50
51 51 Return:
52 52 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
53 53 fecha especificado, de lo contrario retorna False.
54 54
55 55 Excepciones:
56 56 Si el archivo no existe o no puede ser abierto
57 57 Si la cabecera no puede ser leida.
58 58
59 59 """
60 60 basicHeaderObj = BasicHeader(LOCALTIME)
61 61
62 62 try:
63 63 fp = open(filename,'rb')
64 64 except:
65 65 raise IOError, "The file %s can't be opened" %(filename)
66 66
67 67 sts = basicHeaderObj.read(fp)
68 68 fp.close()
69 69
70 70 if not(sts):
71 71 print "Skipping the file %s because it has not a valid header" %(filename)
72 72 return 0
73 73
74 74 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
75 75 return 0
76 76
77 77 return 1
78 78
79 79 def isFileinThisTime(filename, startTime, endTime):
80 80 """
81 81 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
82 82
83 83 Inputs:
84 84 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
85 85
86 86 startTime : tiempo inicial del rango seleccionado en formato datetime.time
87 87
88 88 endTime : tiempo final del rango seleccionado en formato datetime.time
89 89
90 90 Return:
91 91 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
92 92 fecha especificado, de lo contrario retorna False.
93 93
94 94 Excepciones:
95 95 Si el archivo no existe o no puede ser abierto
96 96 Si la cabecera no puede ser leida.
97 97
98 98 """
99 99
100 100
101 101 try:
102 102 fp = open(filename,'rb')
103 103 except:
104 104 raise IOError, "The file %s can't be opened" %(filename)
105 105
106 106 basicHeaderObj = BasicHeader(LOCALTIME)
107 107 sts = basicHeaderObj.read(fp)
108 108 fp.close()
109 109
110 110 thisTime = basicHeaderObj.datatime.time()
111 111
112 112 if not(sts):
113 113 print "Skipping the file %s because it has not a valid header" %(filename)
114 114 return 0
115 115
116 116 if not ((startTime <= thisTime) and (endTime > thisTime)):
117 117 return 0
118 118
119 119 return 1
120 120
121 121 def getlastFileFromPath(path, ext):
122 122 """
123 123 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
124 124 al final de la depuracion devuelve el ultimo file de la lista que quedo.
125 125
126 126 Input:
127 127 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
128 128 ext : extension de los files contenidos en una carpeta
129 129
130 130 Return:
131 131 El ultimo file de una determinada carpeta, no se considera el path.
132 132 """
133 133 validFilelist = []
134 134 fileList = os.listdir(path)
135 135
136 136 # 0 1234 567 89A BCDE
137 137 # H YYYY DDD SSS .ext
138 138
139 139 for file in fileList:
140 140 try:
141 141 year = int(file[1:5])
142 142 doy = int(file[5:8])
143 143
144 144
145 145 except:
146 146 continue
147 147
148 148 if (os.path.splitext(file)[-1].lower() != ext.lower()):
149 149 continue
150 150
151 151 validFilelist.append(file)
152 152
153 153 if validFilelist:
154 154 validFilelist = sorted( validFilelist, key=str.lower )
155 155 return validFilelist[-1]
156 156
157 157 return None
158 158
159 159 def checkForRealPath(path, year, doy, set, ext):
160 160 """
161 161 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
162 162 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
163 163 el path exacto de un determinado file.
164 164
165 165 Example :
166 166 nombre correcto del file es .../.../D2009307/P2009307367.ext
167 167
168 168 Entonces la funcion prueba con las siguientes combinaciones
169 169 .../.../y2009307367.ext
170 170 .../.../Y2009307367.ext
171 171 .../.../x2009307/y2009307367.ext
172 172 .../.../x2009307/Y2009307367.ext
173 173 .../.../X2009307/y2009307367.ext
174 174 .../.../X2009307/Y2009307367.ext
175 175 siendo para este caso, la ultima combinacion de letras, identica al file buscado
176 176
177 177 Return:
178 178 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
179 179 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
180 180 para el filename
181 181 """
182 182 fullfilename = None
183 183 find_flag = False
184 184 filename = None
185 185
186 186 prefixDirList = [None,'d','D']
187 187 if ext.lower() == ".r": #voltage
188 188 prefixFileList = ['d','D']
189 189 elif ext.lower() == ".pdata": #spectra
190 190 prefixFileList = ['p','P']
191 191 else:
192 192 return None, filename
193 193
194 194 #barrido por las combinaciones posibles
195 195 for prefixDir in prefixDirList:
196 196 thispath = path
197 197 if prefixDir != None:
198 198 #formo el nombre del directorio xYYYYDDD (x=d o x=D)
199 199 thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
200 200
201 201 for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"
202 202 filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
203 203 fullfilename = os.path.join( thispath, filename ) #formo el path completo
204 204
205 205 if os.path.exists( fullfilename ): #verifico que exista
206 206 find_flag = True
207 207 break
208 208 if find_flag:
209 209 break
210 210
211 211 if not(find_flag):
212 212 return None, filename
213 213
214 214 return fullfilename, filename
215 215
216 216 class JRODataIO:
217 217
218 218 c = 3E8
219 219
220 220 isConfig = False
221 221
222 222 basicHeaderObj = BasicHeader(LOCALTIME)
223 223
224 224 systemHeaderObj = SystemHeader()
225 225
226 226 radarControllerHeaderObj = RadarControllerHeader()
227 227
228 228 processingHeaderObj = ProcessingHeader()
229 229
230 230 online = 0
231 231
232 232 dtype = None
233 233
234 234 pathList = []
235 235
236 236 filenameList = []
237 237
238 238 filename = None
239 239
240 240 ext = None
241 241
242 242 flagIsNewFile = 1
243 243
244 244 flagTimeBlock = 0
245 245
246 246 flagIsNewBlock = 0
247 247
248 248 fp = None
249 249
250 250 firstHeaderSize = 0
251 251
252 252 basicHeaderSize = 24
253 253
254 254 versionFile = 1103
255 255
256 256 fileSize = None
257 257
258 258 ippSeconds = None
259 259
260 260 fileSizeByHeader = None
261 261
262 262 fileIndex = None
263 263
264 264 profileIndex = None
265 265
266 266 blockIndex = None
267 267
268 268 nTotalBlocks = None
269 269
270 270 maxTimeStep = 30
271 271
272 272 lastUTTime = None
273 273
274 274 datablock = None
275 275
276 276 dataOut = None
277 277
278 278 blocksize = None
279 279
280 280 def __init__(self):
281 281
282 282 raise ValueError, "Not implemented"
283 283
284 284 def run(self):
285 285
286 286 raise ValueError, "Not implemented"
287 287
288 288 def getOutput(self):
289 289
290 290 return self.dataOut
291 291
292 292 class JRODataReader(JRODataIO, ProcessingUnit):
293 293
294 294 nReadBlocks = 0
295 295
296 296 delay = 10 #number of seconds waiting a new file
297 297
298 298 nTries = 3 #quantity tries
299 299
300 300 nFiles = 3 #number of files for searching
301 301
302 302 flagNoMoreFiles = 0
303 303
304 304 def __init__(self):
305 305
306 306 """
307 307
308 308 """
309 309
310 310 raise ValueError, "This method has not been implemented"
311 311
312 312
313 313 def createObjByDefault(self):
314 314 """
315 315
316 316 """
317 317 raise ValueError, "This method has not been implemented"
318 318
319 319 def getBlockDimension(self):
320 320
321 321 raise ValueError, "No implemented"
322 322
323 323 def __searchFilesOffLine(self,
324 324 path,
325 325 startDate,
326 326 endDate,
327 327 startTime=datetime.time(0,0,0),
328 328 endTime=datetime.time(23,59,59),
329 329 set=None,
330 330 expLabel='',
331 331 ext='.r',
332 332 walk=True):
333 333
334 334 pathList = []
335 335
336 336 if not walk:
337 337 pathList.append(path)
338 338
339 339 else:
340 340 dirList = []
341 341 for thisPath in os.listdir(path):
342 342 if os.path.isdir(os.path.join(path,thisPath)):
343 343 dirList.append(thisPath)
344 344
345 345 if not(dirList):
346 346 return None, None
347 347
348 348 thisDate = startDate
349 349
350 350 while(thisDate <= endDate):
351 351 year = thisDate.timetuple().tm_year
352 352 doy = thisDate.timetuple().tm_yday
353 353
354 354 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
355 355 if len(match) == 0:
356 356 thisDate += datetime.timedelta(1)
357 357 continue
358 358
359 359 pathList.append(os.path.join(path,match[0],expLabel))
360 360 thisDate += datetime.timedelta(1)
361 361
362 362 if pathList == []:
363 363 print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
364 364 return None, None
365 365
366 366 print "%d folder(s) was(were) found for the date range: %s-%s" %(len(pathList), startDate, endDate)
367 367
368 368 filenameList = []
369 369 for thisPath in pathList:
370 370
371 371 fileList = glob.glob1(thisPath, "*%s" %ext)
372 372 fileList.sort()
373 373
374 374 for file in fileList:
375 375
376 376 filename = os.path.join(thisPath,file)
377 377
378 378 if isFileinThisTime(filename, startTime, endTime):
379 379 filenameList.append(filename)
380 380
381 381 if not(filenameList):
382 382 print "Any file was found for the time range %s - %s" %(startTime, endTime)
383 383 return None, None
384 384
385 385 print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
386 386
387 387 self.filenameList = filenameList
388 388
389 389 return pathList, filenameList
390 390
391 391 def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True):
392 392
393 393 """
394 394 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
395 395 devuelve el archivo encontrado ademas de otros datos.
396 396
397 397 Input:
398 398 path : carpeta donde estan contenidos los files que contiene data
399 399
400 400 expLabel : Nombre del subexperimento (subfolder)
401 401
402 402 ext : extension de los files
403 403
404 404 walk : Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
405 405
406 406 Return:
407 407 directory : eL directorio donde esta el file encontrado
408 408 filename : el ultimo file de una determinada carpeta
409 409 year : el anho
410 410 doy : el numero de dia del anho
411 411 set : el set del archivo
412 412
413 413
414 414 """
415 415 dirList = []
416 416
417 417 if walk:
418 418
419 419 #Filtra solo los directorios
420 420 for thisPath in os.listdir(path):
421 421 if os.path.isdir(os.path.join(path, thisPath)):
422 422 dirList.append(thisPath)
423 423
424 424 if not(dirList):
425 425 return None, None, None, None, None
426 426
427 427 dirList = sorted( dirList, key=str.lower )
428 428
429 429 doypath = dirList[-1]
430 430 fullpath = os.path.join(path, doypath, expLabel)
431 431
432 432 else:
433 433 fullpath = path
434 434
435 435 filename = getlastFileFromPath(fullpath, ext)
436 436
437 437 if not(filename):
438 438 return None, None, None, None, None
439 439
440 440 if not(self.__verifyFile(os.path.join(fullpath, filename))):
441 441 return None, None, None, None, None
442 442
443 443 year = int( filename[1:5] )
444 444 doy = int( filename[5:8] )
445 445 set = int( filename[8:11] )
446 446
447 447 return fullpath, filename, year, doy, set
448 448
449 449
450 450
451 451 def __setNextFileOffline(self):
452 452
453 453 idFile = self.fileIndex
454 454
455 455 while (True):
456 456 idFile += 1
457 457 if not(idFile < len(self.filenameList)):
458 458 self.flagNoMoreFiles = 1
459 459 print "No more Files"
460 460 return 0
461 461
462 462 filename = self.filenameList[idFile]
463 463
464 464 if not(self.__verifyFile(filename)):
465 465 continue
466 466
467 467 fileSize = os.path.getsize(filename)
468 468 fp = open(filename,'rb')
469 469 break
470 470
471 471 self.flagIsNewFile = 1
472 472 self.fileIndex = idFile
473 473 self.filename = filename
474 474 self.fileSize = fileSize
475 475 self.fp = fp
476 476
477 477 print "Setting the file: %s"%self.filename
478 478
479 479 return 1
480 480
481 481 def __setNextFileOnline(self):
482 482 """
483 483 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
484 484 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
485 485 siguientes.
486 486
487 487 Affected:
488 488 self.flagIsNewFile
489 489 self.filename
490 490 self.fileSize
491 491 self.fp
492 492 self.set
493 493 self.flagNoMoreFiles
494 494
495 495 Return:
496 496 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
497 497 1 : si el file fue abierto con exito y esta listo a ser leido
498 498
499 499 Excepciones:
500 500 Si un determinado file no puede ser abierto
501 501 """
502 502 nFiles = 0
503 503 fileOk_flag = False
504 504 firstTime_flag = True
505 505
506 506 self.set += 1
507 507
508 508 #busca el 1er file disponible
509 509 fullfilename, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
510 510 if fullfilename:
511 511 if self.__verifyFile(fullfilename, False):
512 512 fileOk_flag = True
513 513
514 514 #si no encuentra un file entonces espera y vuelve a buscar
515 515 if not(fileOk_flag):
516 516 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
517 517
518 518 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
519 519 tries = self.nTries
520 520 else:
521 521 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
522 522
523 523 for nTries in range( tries ):
524 524 if firstTime_flag:
525 525 print "\tWaiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
526 526 time.sleep( self.delay )
527 527 else:
528 528 print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
529 529
530 530 fullfilename, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
531 531 if fullfilename:
532 532 if self.__verifyFile(fullfilename):
533 533 fileOk_flag = True
534 534 break
535 535
536 536 if fileOk_flag:
537 537 break
538 538
539 539 firstTime_flag = False
540 540
541 541 print "\tSkipping the file \"%s\" due to this file doesn't exist" % filename
542 542 self.set += 1
543 543
544 544 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
545 545 self.set = 0
546 546 self.doy += 1
547 547
548 548 if fileOk_flag:
549 549 self.fileSize = os.path.getsize( fullfilename )
550 550 self.filename = fullfilename
551 551 self.flagIsNewFile = 1
552 552 if self.fp != None: self.fp.close()
553 553 self.fp = open(fullfilename, 'rb')
554 554 self.flagNoMoreFiles = 0
555 555 print 'Setting the file: %s' % fullfilename
556 556 else:
557 557 self.fileSize = 0
558 558 self.filename = None
559 559 self.flagIsNewFile = 0
560 560 self.fp = None
561 561 self.flagNoMoreFiles = 1
562 562 print 'No more Files'
563 563
564 564 return fileOk_flag
565 565
566 566
567 567 def setNextFile(self):
568 568 if self.fp != None:
569 569 self.fp.close()
570 570
571 571 if self.online:
572 572 newFile = self.__setNextFileOnline()
573 573 else:
574 574 newFile = self.__setNextFileOffline()
575 575
576 576 if not(newFile):
577 577 return 0
578 578
579 579 self.__readFirstHeader()
580 580 self.nReadBlocks = 0
581 581 return 1
582 582
583 583 def __waitNewBlock(self):
584 584 """
585 585 Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
586 586
587 587 Si el modo de lectura es OffLine siempre retorn 0
588 588 """
589 589 if not self.online:
590 590 return 0
591 591
592 592 if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
593 593 return 0
594 594
595 595 currentPointer = self.fp.tell()
596 596
597 597 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
598 598
599 599 for nTries in range( self.nTries ):
600 600
601 601 self.fp.close()
602 602 self.fp = open( self.filename, 'rb' )
603 603 self.fp.seek( currentPointer )
604 604
605 605 self.fileSize = os.path.getsize( self.filename )
606 606 currentSize = self.fileSize - currentPointer
607 607
608 608 if ( currentSize >= neededSize ):
609 609 self.__rdBasicHeader()
610 610 return 1
611 611
612 612 print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
613 613 time.sleep( self.delay )
614 614
615 615
616 616 return 0
617 617
618 618 def __setNewBlock(self):
619 619
620 620 if self.fp == None:
621 621 return 0
622 622
623 623 if self.flagIsNewFile:
624 624 return 1
625 625
626 626 self.lastUTTime = self.basicHeaderObj.utc
627 627 currentSize = self.fileSize - self.fp.tell()
628 628 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
629 629
630 630 if (currentSize >= neededSize):
631 631 self.__rdBasicHeader()
632 632 return 1
633 633
634 634 if self.__waitNewBlock():
635 635 return 1
636 636
637 637 if not(self.setNextFile()):
638 638 return 0
639 639
640 640 deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
641 641
642 642 self.flagTimeBlock = 0
643 643
644 644 if deltaTime > self.maxTimeStep:
645 645 self.flagTimeBlock = 1
646 646
647 647 return 1
648 648
649 649
650 650 def readNextBlock(self):
651 651 if not(self.__setNewBlock()):
652 652 return 0
653 653
654 654 if not(self.readBlock()):
655 655 return 0
656 656
657 657 return 1
658 658
659 659 def __rdProcessingHeader(self, fp=None):
660 660 if fp == None:
661 661 fp = self.fp
662 662
663 663 self.processingHeaderObj.read(fp)
664 664
665 665 def __rdRadarControllerHeader(self, fp=None):
666 666 if fp == None:
667 667 fp = self.fp
668 668
669 669 self.radarControllerHeaderObj.read(fp)
670 670
671 671 def __rdSystemHeader(self, fp=None):
672 672 if fp == None:
673 673 fp = self.fp
674 674
675 675 self.systemHeaderObj.read(fp)
676 676
677 677 def __rdBasicHeader(self, fp=None):
678 678 if fp == None:
679 679 fp = self.fp
680 680
681 681 self.basicHeaderObj.read(fp)
682 682
683 683
684 684 def __readFirstHeader(self):
685 685 self.__rdBasicHeader()
686 686 self.__rdSystemHeader()
687 687 self.__rdRadarControllerHeader()
688 688 self.__rdProcessingHeader()
689 689
690 690 self.firstHeaderSize = self.basicHeaderObj.size
691 691
692 692 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
693 693 if datatype == 0:
694 694 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
695 695 elif datatype == 1:
696 696 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
697 697 elif datatype == 2:
698 698 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
699 699 elif datatype == 3:
700 700 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
701 701 elif datatype == 4:
702 702 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
703 703 elif datatype == 5:
704 704 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
705 705 else:
706 706 raise ValueError, 'Data type was not defined'
707 707
708 708 self.dtype = datatype_str
709 709 self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
710 710 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
711 711 # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
712 712 # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
713 713 self.getBlockDimension()
714 714
715 715
716 716 def __verifyFile(self, filename, msgFlag=True):
717 717 msg = None
718 718 try:
719 719 fp = open(filename, 'rb')
720 720 currentPosition = fp.tell()
721 721 except:
722 722 if msgFlag:
723 723 print "The file %s can't be opened" % (filename)
724 724 return False
725 725
726 726 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
727 727
728 728 if neededSize == 0:
729 729 basicHeaderObj = BasicHeader(LOCALTIME)
730 730 systemHeaderObj = SystemHeader()
731 731 radarControllerHeaderObj = RadarControllerHeader()
732 732 processingHeaderObj = ProcessingHeader()
733 733
734 734 try:
735 735 if not( basicHeaderObj.read(fp) ): raise IOError
736 736 if not( systemHeaderObj.read(fp) ): raise IOError
737 737 if not( radarControllerHeaderObj.read(fp) ): raise IOError
738 738 if not( processingHeaderObj.read(fp) ): raise IOError
739 739 data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
740 740
741 741 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
742 742
743 743 except:
744 744 if msgFlag:
745 745 print "\tThe file %s is empty or it hasn't enough data" % filename
746 746
747 747 fp.close()
748 748 return False
749 749 else:
750 750 msg = "\tSkipping the file %s due to it hasn't enough data" %filename
751 751
752 752 fp.close()
753 753 fileSize = os.path.getsize(filename)
754 754 currentSize = fileSize - currentPosition
755 755 if currentSize < neededSize:
756 756 if msgFlag and (msg != None):
757 757 print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
758 758 return False
759 759
760 760 return True
761 761
762 762 def setup(self,
763 763 path=None,
764 764 startDate=None,
765 765 endDate=None,
766 766 startTime=datetime.time(0,0,0),
767 767 endTime=datetime.time(23,59,59),
768 768 set=0,
769 769 expLabel = "",
770 770 ext = None,
771 771 online = False,
772 772 delay = 60,
773 773 walk = True):
774 774
775 775 if path == None:
776 776 raise ValueError, "The path is not valid"
777 777
778 778 if ext == None:
779 779 ext = self.ext
780 780
781 781 if online:
782 782 print "Searching files in online mode..."
783 783
784 784 for nTries in range( self.nTries ):
785 785 fullpath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk)
786 786
787 787 if fullpath:
788 788 break
789 789
790 790 print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
791 791 time.sleep( self.delay )
792 792
793 793 if not(fullpath):
794 794 print "There 'isn't valied files in %s" % path
795 795 return None
796 796
797 797 self.year = year
798 798 self.doy = doy
799 799 self.set = set - 1
800 800 self.path = path
801 801
802 802 else:
803 803 print "Searching files in offline mode ..."
804 804 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
805 805 startTime=startTime, endTime=endTime,
806 806 set=set, expLabel=expLabel, ext=ext,
807 807 walk=walk)
808 808
809 809 if not(pathList):
810 810 print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
811 811 datetime.datetime.combine(startDate,startTime).ctime(),
812 812 datetime.datetime.combine(endDate,endTime).ctime())
813 813
814 814 sys.exit(-1)
815 815
816 816
817 817 self.fileIndex = -1
818 818 self.pathList = pathList
819 819 self.filenameList = filenameList
820 820
821 821 self.online = online
822 822 self.delay = delay
823 823 ext = ext.lower()
824 824 self.ext = ext
825 825
826 826 if not(self.setNextFile()):
827 827 if (startDate!=None) and (endDate!=None):
828 828 print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
829 829 elif startDate != None:
830 830 print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
831 831 else:
832 832 print "No files"
833 833
834 834 sys.exit(-1)
835 835
836 836 # self.updateDataHeader()
837 837
838 838 return self.dataOut
839 839
840 840 def getData():
841 841
842 842 raise ValueError, "This method has not been implemented"
843 843
844 844 def hasNotDataInBuffer():
845 845
846 846 raise ValueError, "This method has not been implemented"
847 847
848 848 def readBlock():
849 849
850 850 raise ValueError, "This method has not been implemented"
851 851
852 852 def isEndProcess(self):
853 853
854 854 return self.flagNoMoreFiles
855 855
856 856 def printReadBlocks(self):
857 857
858 858 print "Number of read blocks per file %04d" %self.nReadBlocks
859 859
860 860 def printTotalBlocks(self):
861 861
862 862 print "Number of read blocks %04d" %self.nTotalBlocks
863 863
864 864 def printInfo(self):
865 865
866 866 print self.basicHeaderObj.printInfo()
867 867 print self.systemHeaderObj.printInfo()
868 868 print self.radarControllerHeaderObj.printInfo()
869 869 print self.processingHeaderObj.printInfo()
870 870
871 871
872 872 def run(self, **kwargs):
873 873
874 874 if not(self.isConfig):
875 875
876 876 # self.dataOut = dataOut
877 877 self.setup(**kwargs)
878 878 self.isConfig = True
879 879
880 880 self.getData()
881 881
882 882 class JRODataWriter(JRODataIO, Operation):
883 883
884 884 """
885 885 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
886 886 de los datos siempre se realiza por bloques.
887 887 """
888 888
889 889 blockIndex = 0
890 890
891 891 path = None
892 892
893 893 setFile = None
894 894
895 895 profilesPerBlock = None
896 896
897 897 blocksPerFile = None
898 898
899 899 nWriteBlocks = 0
900 900
901 901 def __init__(self, dataOut=None):
902 902 raise ValueError, "Not implemented"
903 903
904 904
905 905 def hasAllDataInBuffer(self):
906 906 raise ValueError, "Not implemented"
907 907
908 908
909 909 def setBlockDimension(self):
910 910 raise ValueError, "Not implemented"
911 911
912 912
913 913 def writeBlock(self):
914 914 raise ValueError, "No implemented"
915 915
916 916
917 917 def putData(self):
918 918 raise ValueError, "No implemented"
919 919
920 920 def getDataHeader(self):
921 921 """
922 922 Obtiene una copia del First Header
923 923
924 924 Affected:
925 925
926 926 self.basicHeaderObj
927 927 self.systemHeaderObj
928 928 self.radarControllerHeaderObj
929 929 self.processingHeaderObj self.
930 930
931 931 Return:
932 932 None
933 933 """
934 934
935 935 raise ValueError, "No implemented"
936 936
937 937 def getBasicHeader(self):
938 938
939 939 self.basicHeaderObj.size = self.basicHeaderSize #bytes
940 940 self.basicHeaderObj.version = self.versionFile
941 941 self.basicHeaderObj.dataBlock = self.nTotalBlocks
942 942
943 943 utc = numpy.floor(self.dataOut.utctime)
944 944 milisecond = (self.dataOut.utctime - utc)* 1000.0
945 945
946 946 self.basicHeaderObj.utc = utc
947 947 self.basicHeaderObj.miliSecond = milisecond
948 948 self.basicHeaderObj.timeZone = 0
949 949 self.basicHeaderObj.dstFlag = 0
950 950 self.basicHeaderObj.errorCount = 0
951 951
952 952 def __writeFirstHeader(self):
953 953 """
954 954 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
955 955
956 956 Affected:
957 957 __dataType
958 958
959 959 Return:
960 960 None
961 961 """
962 962
963 963 # CALCULAR PARAMETROS
964 964
965 965 sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
966 966 self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
967 967
968 968 self.basicHeaderObj.write(self.fp)
969 969 self.systemHeaderObj.write(self.fp)
970 970 self.radarControllerHeaderObj.write(self.fp)
971 971 self.processingHeaderObj.write(self.fp)
972 972
973 973 self.dtype = self.dataOut.dtype
974 974
975 975 def __setNewBlock(self):
976 976 """
977 977 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
978 978
979 979 Return:
980 980 0 : si no pudo escribir nada
981 981 1 : Si escribio el Basic el First Header
982 982 """
983 983 if self.fp == None:
984 984 self.setNextFile()
985 985
986 986 if self.flagIsNewFile:
987 987 return 1
988 988
989 989 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
990 990 self.basicHeaderObj.write(self.fp)
991 991 return 1
992 992
993 993 if not( self.setNextFile() ):
994 994 return 0
995 995
996 996 return 1
997 997
998 998
999 999 def writeNextBlock(self):
1000 1000 """
1001 1001 Selecciona el bloque siguiente de datos y los escribe en un file
1002 1002
1003 1003 Return:
1004 1004 0 : Si no hizo pudo escribir el bloque de datos
1005 1005 1 : Si no pudo escribir el bloque de datos
1006 1006 """
1007 1007 if not( self.__setNewBlock() ):
1008 1008 return 0
1009 1009
1010 1010 self.writeBlock()
1011 1011
1012 1012 return 1
1013 1013
1014 1014 def setNextFile(self):
1015 1015 """
1016 1016 Determina el siguiente file que sera escrito
1017 1017
1018 1018 Affected:
1019 1019 self.filename
1020 1020 self.subfolder
1021 1021 self.fp
1022 1022 self.setFile
1023 1023 self.flagIsNewFile
1024 1024
1025 1025 Return:
1026 1026 0 : Si el archivo no puede ser escrito
1027 1027 1 : Si el archivo esta listo para ser escrito
1028 1028 """
1029 1029 ext = self.ext
1030 1030 path = self.path
1031 1031
1032 1032 if self.fp != None:
1033 1033 self.fp.close()
1034 1034
1035 timeTuple = time.localtime( self.dataOut.dataUtcTime)
1035 timeTuple = time.localtime( self.dataOut.utctime)
1036 1036 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1037 1037
1038 1038 fullpath = os.path.join( path, subfolder )
1039 1039 if not( os.path.exists(fullpath) ):
1040 1040 os.mkdir(fullpath)
1041 1041 self.setFile = -1 #inicializo mi contador de seteo
1042 1042 else:
1043 1043 filesList = os.listdir( fullpath )
1044 1044 if len( filesList ) > 0:
1045 1045 filesList = sorted( filesList, key=str.lower )
1046 1046 filen = filesList[-1]
1047 1047 # el filename debera tener el siguiente formato
1048 1048 # 0 1234 567 89A BCDE (hex)
1049 1049 # x YYYY DDD SSS .ext
1050 1050 if isNumber( filen[8:11] ):
1051 1051 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1052 1052 else:
1053 1053 self.setFile = -1
1054 1054 else:
1055 1055 self.setFile = -1 #inicializo mi contador de seteo
1056 1056
1057 1057 setFile = self.setFile
1058 1058 setFile += 1
1059 1059
1060 1060 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
1061 1061 timeTuple.tm_year,
1062 1062 timeTuple.tm_yday,
1063 1063 setFile,
1064 1064 ext )
1065 1065
1066 1066 filename = os.path.join( path, subfolder, file )
1067 1067
1068 1068 fp = open( filename,'wb' )
1069 1069
1070 1070 self.blockIndex = 0
1071 1071
1072 1072 #guardando atributos
1073 1073 self.filename = filename
1074 1074 self.subfolder = subfolder
1075 1075 self.fp = fp
1076 1076 self.setFile = setFile
1077 1077 self.flagIsNewFile = 1
1078 1078
1079 1079 self.getDataHeader()
1080 1080
1081 1081 print 'Writing the file: %s'%self.filename
1082 1082
1083 1083 self.__writeFirstHeader()
1084 1084
1085 1085 return 1
1086 1086
1087 1087 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=None, set=0, ext=None):
1088 1088 """
1089 1089 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1090 1090
1091 1091 Inputs:
1092 1092 path : el path destino en el cual se escribiran los files a crear
1093 1093 format : formato en el cual sera salvado un file
1094 1094 set : el setebo del file
1095 1095
1096 1096 Return:
1097 1097 0 : Si no realizo un buen seteo
1098 1098 1 : Si realizo un buen seteo
1099 1099 """
1100 1100
1101 1101 if ext == None:
1102 1102 ext = self.ext
1103 1103
1104 1104 ext = ext.lower()
1105 1105
1106 1106 self.ext = ext
1107 1107
1108 1108 self.path = path
1109 1109
1110 1110 self.setFile = set - 1
1111 1111
1112 1112 self.blocksPerFile = blocksPerFile
1113 1113
1114 1114 self.profilesPerBlock = profilesPerBlock
1115 1115
1116 1116 self.dataOut = dataOut
1117 1117
1118 1118 if not(self.setNextFile()):
1119 1119 print "There isn't a next file"
1120 1120 return 0
1121 1121
1122 1122 self.setBlockDimension()
1123 1123
1124 1124 return 1
1125 1125
1126 1126 def run(self, dataOut, **kwargs):
1127 1127
1128 1128 if not(self.isConfig):
1129 1129
1130 1130 self.setup(dataOut, **kwargs)
1131 1131 self.isConfig = True
1132 1132
1133 1133 self.putData()
1134 1134
1135 1135 class VoltageReader(JRODataReader):
1136 1136 """
1137 1137 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
1138 1138 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
1139 1139 perfiles*alturas*canales) son almacenados en la variable "buffer".
1140 1140
1141 1141 perfiles * alturas * canales
1142 1142
1143 1143 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
1144 1144 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
1145 1145 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
1146 1146 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
1147 1147
1148 1148 Example:
1149 1149
1150 1150 dpath = "/home/myuser/data"
1151 1151
1152 1152 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
1153 1153
1154 1154 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
1155 1155
1156 1156 readerObj = VoltageReader()
1157 1157
1158 1158 readerObj.setup(dpath, startTime, endTime)
1159 1159
1160 1160 while(True):
1161 1161
1162 1162 #to get one profile
1163 1163 profile = readerObj.getData()
1164 1164
1165 1165 #print the profile
1166 1166 print profile
1167 1167
1168 1168 #If you want to see all datablock
1169 1169 print readerObj.datablock
1170 1170
1171 1171 if readerObj.flagNoMoreFiles:
1172 1172 break
1173 1173
1174 1174 """
1175 1175
1176 1176 ext = ".r"
1177 1177
1178 1178 optchar = "D"
1179 1179 dataOut = None
1180 1180
1181 1181
1182 1182 def __init__(self):
1183 1183 """
1184 1184 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
1185 1185
1186 1186 Input:
1187 1187 dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para
1188 1188 almacenar un perfil de datos cada vez que se haga un requerimiento
1189 1189 (getData). El perfil sera obtenido a partir del buffer de datos,
1190 1190 si el buffer esta vacio se hara un nuevo proceso de lectura de un
1191 1191 bloque de datos.
1192 1192 Si este parametro no es pasado se creara uno internamente.
1193 1193
1194 1194 Variables afectadas:
1195 1195 self.dataOut
1196 1196
1197 1197 Return:
1198 1198 None
1199 1199 """
1200 1200
1201 1201 self.isConfig = False
1202 1202
1203 1203 self.datablock = None
1204 1204
1205 1205 self.utc = 0
1206 1206
1207 1207 self.ext = ".r"
1208 1208
1209 1209 self.optchar = "D"
1210 1210
1211 1211 self.basicHeaderObj = BasicHeader(LOCALTIME)
1212 1212
1213 1213 self.systemHeaderObj = SystemHeader()
1214 1214
1215 1215 self.radarControllerHeaderObj = RadarControllerHeader()
1216 1216
1217 1217 self.processingHeaderObj = ProcessingHeader()
1218 1218
1219 1219 self.online = 0
1220 1220
1221 1221 self.fp = None
1222 1222
1223 1223 self.idFile = None
1224 1224
1225 1225 self.dtype = None
1226 1226
1227 1227 self.fileSizeByHeader = None
1228 1228
1229 1229 self.filenameList = []
1230 1230
1231 1231 self.filename = None
1232 1232
1233 1233 self.fileSize = None
1234 1234
1235 1235 self.firstHeaderSize = 0
1236 1236
1237 1237 self.basicHeaderSize = 24
1238 1238
1239 1239 self.pathList = []
1240 1240
1241 1241 self.filenameList = []
1242 1242
1243 1243 self.lastUTTime = 0
1244 1244
1245 1245 self.maxTimeStep = 30
1246 1246
1247 1247 self.flagNoMoreFiles = 0
1248 1248
1249 1249 self.set = 0
1250 1250
1251 1251 self.path = None
1252 1252
1253 1253 self.profileIndex = 9999
1254 1254
1255 1255 self.delay = 3 #seconds
1256 1256
1257 1257 self.nTries = 3 #quantity tries
1258 1258
1259 1259 self.nFiles = 3 #number of files for searching
1260 1260
1261 1261 self.nReadBlocks = 0
1262 1262
1263 1263 self.flagIsNewFile = 1
1264 1264
1265 1265 self.ippSeconds = 0
1266 1266
1267 1267 self.flagTimeBlock = 0
1268 1268
1269 1269 self.flagIsNewBlock = 0
1270 1270
1271 1271 self.nTotalBlocks = 0
1272 1272
1273 1273 self.blocksize = 0
1274 1274
1275 1275 self.dataOut = self.createObjByDefault()
1276 1276
1277 1277 def createObjByDefault(self):
1278 1278
1279 1279 dataObj = Voltage()
1280 1280
1281 1281 return dataObj
1282 1282
1283 1283 def __hasNotDataInBuffer(self):
1284 1284 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
1285 1285 return 1
1286 1286 return 0
1287 1287
1288 1288
1289 1289 def getBlockDimension(self):
1290 1290 """
1291 1291 Obtiene la cantidad de puntos a leer por cada bloque de datos
1292 1292
1293 1293 Affected:
1294 1294 self.blocksize
1295 1295
1296 1296 Return:
1297 1297 None
1298 1298 """
1299 1299 pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
1300 1300 self.blocksize = pts2read
1301 1301
1302 1302
1303 1303 def readBlock(self):
1304 1304 """
1305 1305 readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
1306 1306 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
1307 1307 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
1308 1308 es seteado a 0
1309 1309
1310 1310 Inputs:
1311 1311 None
1312 1312
1313 1313 Return:
1314 1314 None
1315 1315
1316 1316 Affected:
1317 1317 self.profileIndex
1318 1318 self.datablock
1319 1319 self.flagIsNewFile
1320 1320 self.flagIsNewBlock
1321 1321 self.nTotalBlocks
1322 1322
1323 1323 Exceptions:
1324 1324 Si un bloque leido no es un bloque valido
1325 1325 """
1326 1326
1327 1327 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
1328 1328
1329 1329 try:
1330 1330 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
1331 1331 except:
1332 1332 print "The read block (%3d) has not enough data" %self.nReadBlocks
1333 1333 return 0
1334 1334
1335 1335 junk = numpy.transpose(junk, (2,0,1))
1336 1336 self.datablock = junk['real'] + junk['imag']*1j
1337 1337
1338 1338 self.profileIndex = 0
1339 1339
1340 1340 self.flagIsNewFile = 0
1341 1341 self.flagIsNewBlock = 1
1342 1342
1343 1343 self.nTotalBlocks += 1
1344 1344 self.nReadBlocks += 1
1345 1345
1346 1346 return 1
1347 1347
1348 1348
1349 1349 def getData(self):
1350 1350 """
1351 1351 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
1352 1352 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1353 1353 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
1354 1354
1355 1355 Ademas incrementa el contador del buffer en 1.
1356 1356
1357 1357 Return:
1358 1358 data : retorna un perfil de voltages (alturas * canales) copiados desde el
1359 1359 buffer. Si no hay mas archivos a leer retorna None.
1360 1360
1361 1361 Variables afectadas:
1362 1362 self.dataOut
1363 1363 self.profileIndex
1364 1364
1365 1365 Affected:
1366 1366 self.dataOut
1367 1367 self.profileIndex
1368 1368 self.flagTimeBlock
1369 1369 self.flagIsNewBlock
1370 1370 """
1371 1371
1372 1372 if self.flagNoMoreFiles:
1373 1373 self.dataOut.flagNoData = True
1374 1374 print 'Process finished'
1375 1375 return 0
1376 1376
1377 1377 self.flagTimeBlock = 0
1378 1378 self.flagIsNewBlock = 0
1379 1379
1380 1380 if self.__hasNotDataInBuffer():
1381 1381
1382 1382 if not( self.readNextBlock() ):
1383 1383 return 0
1384 1384
1385 self.dataOut.dtype = self.dtype
1385 self.dataOut.dtype = numpy.dtype([('real','<f8'),('imag','<f8')]) #self.dtype
1386 1386
1387 1387 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
1388 1388
1389 1389 xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
1390 1390
1391 1391 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
1392 1392
1393 1393 self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
1394 1394
1395 1395 self.dataOut.flagTimeBlock = self.flagTimeBlock
1396 1396
1397 1397 self.dataOut.ippSeconds = self.ippSeconds
1398 1398
1399 1399 self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
1400 1400
1401 1401 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
1402 1402
1403 1403 self.dataOut.flagShiftFFT = False
1404 1404
1405 1405 if self.radarControllerHeaderObj.code != None:
1406 1406
1407 1407 self.dataOut.nCode = self.radarControllerHeaderObj.nCode
1408 1408
1409 1409 self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
1410 1410
1411 1411 self.dataOut.code = self.radarControllerHeaderObj.code
1412 1412
1413 1413 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
1414 1414
1415 1415 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
1416 1416
1417 1417 self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada
1418 1418
1419 1419 self.dataOut.flagDeflipData = False #asumo q la data no esta sin flip
1420 1420
1421 1421 self.dataOut.flagShiftFFT = False
1422 1422
1423 1423
1424 1424 # self.updateDataHeader()
1425 1425
1426 1426 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1427 1427
1428 1428 if self.datablock == None:
1429 1429 self.dataOut.flagNoData = True
1430 1430 return 0
1431 1431
1432 1432 self.dataOut.data = self.datablock[:,self.profileIndex,:]
1433 1433
1434 1434 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
1435 1435
1436 1436 self.profileIndex += 1
1437 1437
1438 1438 self.dataOut.flagNoData = False
1439 1439
1440 1440 # print self.profileIndex, self.dataOut.utctime
1441 1441 # if self.profileIndex == 800:
1442 1442 # a=1
1443 1443
1444 1444
1445 1445 return self.dataOut.data
1446 1446
1447 1447
1448 1448 class VoltageWriter(JRODataWriter):
1449 1449 """
1450 1450 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
1451 1451 de los datos siempre se realiza por bloques.
1452 1452 """
1453 1453
1454 1454 ext = ".r"
1455 1455
1456 1456 optchar = "D"
1457 1457
1458 1458 shapeBuffer = None
1459 1459
1460 1460
1461 1461 def __init__(self):
1462 1462 """
1463 1463 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
1464 1464
1465 1465 Affected:
1466 1466 self.dataOut
1467 1467
1468 1468 Return: None
1469 1469 """
1470 1470
1471 1471 self.nTotalBlocks = 0
1472 1472
1473 1473 self.profileIndex = 0
1474 1474
1475 1475 self.isConfig = False
1476 1476
1477 1477 self.fp = None
1478 1478
1479 1479 self.flagIsNewFile = 1
1480 1480
1481 1481 self.nTotalBlocks = 0
1482 1482
1483 1483 self.flagIsNewBlock = 0
1484 1484
1485 1485 self.setFile = None
1486 1486
1487 1487 self.dtype = None
1488 1488
1489 1489 self.path = None
1490 1490
1491 1491 self.filename = None
1492 1492
1493 1493 self.basicHeaderObj = BasicHeader(LOCALTIME)
1494 1494
1495 1495 self.systemHeaderObj = SystemHeader()
1496 1496
1497 1497 self.radarControllerHeaderObj = RadarControllerHeader()
1498 1498
1499 1499 self.processingHeaderObj = ProcessingHeader()
1500 1500
1501 1501 def hasAllDataInBuffer(self):
1502 1502 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
1503 1503 return 1
1504 1504 return 0
1505 1505
1506 1506
1507 1507 def setBlockDimension(self):
1508 1508 """
1509 1509 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
1510 1510
1511 1511 Affected:
1512 1512 self.shape_spc_Buffer
1513 1513 self.shape_cspc_Buffer
1514 1514 self.shape_dc_Buffer
1515 1515
1516 1516 Return: None
1517 1517 """
1518 1518 self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
1519 1519 self.processingHeaderObj.nHeights,
1520 1520 self.systemHeaderObj.nChannels)
1521 1521
1522 1522 self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
1523 1523 self.processingHeaderObj.profilesPerBlock,
1524 1524 self.processingHeaderObj.nHeights),
1525 1525 dtype=numpy.dtype('complex'))
1526 1526
1527 1527
1528 1528 def writeBlock(self):
1529 1529 """
1530 1530 Escribe el buffer en el file designado
1531 1531
1532 1532 Affected:
1533 1533 self.profileIndex
1534 1534 self.flagIsNewFile
1535 1535 self.flagIsNewBlock
1536 1536 self.nTotalBlocks
1537 1537 self.blockIndex
1538 1538
1539 1539 Return: None
1540 1540 """
1541 1541 data = numpy.zeros( self.shapeBuffer, self.dtype )
1542 1542
1543 1543 junk = numpy.transpose(self.datablock, (1,2,0))
1544 1544
1545 1545 data['real'] = junk.real
1546 1546 data['imag'] = junk.imag
1547 1547
1548 1548 data = data.reshape( (-1) )
1549 1549
1550 1550 data.tofile( self.fp )
1551 1551
1552 1552 self.datablock.fill(0)
1553 1553
1554 1554 self.profileIndex = 0
1555 1555 self.flagIsNewFile = 0
1556 1556 self.flagIsNewBlock = 1
1557 1557
1558 1558 self.blockIndex += 1
1559 1559 self.nTotalBlocks += 1
1560 1560
1561 1561 def putData(self):
1562 1562 """
1563 1563 Setea un bloque de datos y luego los escribe en un file
1564 1564
1565 1565 Affected:
1566 1566 self.flagIsNewBlock
1567 1567 self.profileIndex
1568 1568
1569 1569 Return:
1570 1570 0 : Si no hay data o no hay mas files que puedan escribirse
1571 1571 1 : Si se escribio la data de un bloque en un file
1572 1572 """
1573 1573 if self.dataOut.flagNoData:
1574 1574 return 0
1575 1575
1576 1576 self.flagIsNewBlock = 0
1577 1577
1578 1578 if self.dataOut.flagTimeBlock:
1579 1579
1580 1580 self.datablock.fill(0)
1581 1581 self.profileIndex = 0
1582 1582 self.setNextFile()
1583 1583
1584 1584 if self.profileIndex == 0:
1585 1585 self.getBasicHeader()
1586 1586
1587 1587 self.datablock[:,self.profileIndex,:] = self.dataOut.data
1588 1588
1589 1589 self.profileIndex += 1
1590 1590
1591 1591 if self.hasAllDataInBuffer():
1592 1592 #if self.flagIsNewFile:
1593 1593 self.writeNextBlock()
1594 1594 # self.getDataHeader()
1595 1595
1596 1596 return 1
1597 1597
1598 1598 def __getProcessFlags(self):
1599 1599
1600 1600 processFlags = 0
1601 1601
1602 1602 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
1603 1603 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
1604 1604 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
1605 1605 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
1606 1606 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
1607 1607 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
1608 1608
1609 1609 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
1610 1610
1611 1611
1612 1612
1613 1613 datatypeValueList = [PROCFLAG.DATATYPE_CHAR,
1614 1614 PROCFLAG.DATATYPE_SHORT,
1615 1615 PROCFLAG.DATATYPE_LONG,
1616 1616 PROCFLAG.DATATYPE_INT64,
1617 1617 PROCFLAG.DATATYPE_FLOAT,
1618 1618 PROCFLAG.DATATYPE_DOUBLE]
1619 1619
1620 1620
1621 1621 for index in range(len(dtypeList)):
1622 1622 if self.dataOut.dtype == dtypeList[index]:
1623 1623 dtypeValue = datatypeValueList[index]
1624 1624 break
1625 1625
1626 1626 processFlags += dtypeValue
1627 1627
1628 1628 if self.dataOut.flagDecodeData:
1629 1629 processFlags += PROCFLAG.DECODE_DATA
1630 1630
1631 1631 if self.dataOut.flagDeflipData:
1632 1632 processFlags += PROCFLAG.DEFLIP_DATA
1633 1633
1634 1634 if self.dataOut.code != None:
1635 1635 processFlags += PROCFLAG.DEFINE_PROCESS_CODE
1636 1636
1637 1637 if self.dataOut.nCohInt > 1:
1638 1638 processFlags += PROCFLAG.COHERENT_INTEGRATION
1639 1639
1640 1640 return processFlags
1641 1641
1642 1642
1643 1643 def __getBlockSize(self):
1644 1644 '''
1645 1645 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
1646 1646 '''
1647 1647
1648 1648 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
1649 1649 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
1650 1650 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
1651 1651 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
1652 1652 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
1653 1653 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
1654 1654
1655 1655 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
1656 1656 datatypeValueList = [1,2,4,8,4,8]
1657 1657 for index in range(len(dtypeList)):
1658 1658 if self.dataOut.dtype == dtypeList[index]:
1659 1659 datatypeValue = datatypeValueList[index]
1660 1660 break
1661 1661
1662 1662 blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.dataOut.nProfiles * datatypeValue * 2)
1663 1663
1664 1664 return blocksize
1665 1665
1666 1666 def getDataHeader(self):
1667 1667
1668 1668 """
1669 1669 Obtiene una copia del First Header
1670 1670
1671 1671 Affected:
1672 1672 self.systemHeaderObj
1673 1673 self.radarControllerHeaderObj
1674 1674 self.dtype
1675 1675
1676 1676 Return:
1677 1677 None
1678 1678 """
1679 1679
1680 1680 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
1681 1681 self.systemHeaderObj.nChannels = self.dataOut.nChannels
1682 1682 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
1683 1683
1684 1684 self.getBasicHeader()
1685 1685
1686 1686 processingHeaderSize = 40 # bytes
1687 1687 self.processingHeaderObj.dtype = 0 # Voltage
1688 1688 self.processingHeaderObj.blockSize = self.__getBlockSize()
1689 1689 self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
1690 1690 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
1691 1691 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
1692 1692 self.processingHeaderObj.processFlags = self.__getProcessFlags()
1693 1693 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
1694 1694 self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
1695 1695 self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
1696 1696
1697 1697 if self.dataOut.code != None:
1698 1698 self.processingHeaderObj.code = self.dataOut.code
1699 1699 self.processingHeaderObj.nCode = self.dataOut.nCode
1700 1700 self.processingHeaderObj.nBaud = self.dataOut.nBaud
1701 1701 codesize = int(8 + 4 * self.dataOut.nCode * self.dataOut.nBaud)
1702 1702 processingHeaderSize += codesize
1703 1703
1704 1704 if self.processingHeaderObj.nWindows != 0:
1705 1705 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
1706 1706 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
1707 1707 self.processingHeaderObj.nHeights = self.dataOut.nHeights
1708 1708 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
1709 1709 processingHeaderSize += 12
1710 1710
1711 1711 self.processingHeaderObj.size = processingHeaderSize
1712 1712
1713 1713 class SpectraReader(JRODataReader):
1714 1714 """
1715 1715 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
1716 1716 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
1717 1717 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
1718 1718
1719 1719 paresCanalesIguales * alturas * perfiles (Self Spectra)
1720 1720 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
1721 1721 canales * alturas (DC Channels)
1722 1722
1723 1723 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
1724 1724 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
1725 1725 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
1726 1726 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
1727 1727
1728 1728 Example:
1729 1729 dpath = "/home/myuser/data"
1730 1730
1731 1731 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
1732 1732
1733 1733 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
1734 1734
1735 1735 readerObj = SpectraReader()
1736 1736
1737 1737 readerObj.setup(dpath, startTime, endTime)
1738 1738
1739 1739 while(True):
1740 1740
1741 1741 readerObj.getData()
1742 1742
1743 1743 print readerObj.data_spc
1744 1744
1745 1745 print readerObj.data_cspc
1746 1746
1747 1747 print readerObj.data_dc
1748 1748
1749 1749 if readerObj.flagNoMoreFiles:
1750 1750 break
1751 1751
1752 1752 """
1753 1753
1754 1754 pts2read_SelfSpectra = 0
1755 1755
1756 1756 pts2read_CrossSpectra = 0
1757 1757
1758 1758 pts2read_DCchannels = 0
1759 1759
1760 1760 ext = ".pdata"
1761 1761
1762 1762 optchar = "P"
1763 1763
1764 1764 dataOut = None
1765 1765
1766 1766 nRdChannels = None
1767 1767
1768 1768 nRdPairs = None
1769 1769
1770 1770 rdPairList = []
1771 1771
1772 1772
1773 1773 def __init__(self):
1774 1774 """
1775 1775 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
1776 1776
1777 1777 Inputs:
1778 1778 dataOut : Objeto de la clase Spectra. Este objeto sera utilizado para
1779 1779 almacenar un perfil de datos cada vez que se haga un requerimiento
1780 1780 (getData). El perfil sera obtenido a partir del buffer de datos,
1781 1781 si el buffer esta vacio se hara un nuevo proceso de lectura de un
1782 1782 bloque de datos.
1783 1783 Si este parametro no es pasado se creara uno internamente.
1784 1784
1785 1785 Affected:
1786 1786 self.dataOut
1787 1787
1788 1788 Return : None
1789 1789 """
1790 1790
1791 1791 self.isConfig = False
1792 1792
1793 1793 self.pts2read_SelfSpectra = 0
1794 1794
1795 1795 self.pts2read_CrossSpectra = 0
1796 1796
1797 1797 self.pts2read_DCchannels = 0
1798 1798
1799 1799 self.datablock = None
1800 1800
1801 1801 self.utc = None
1802 1802
1803 1803 self.ext = ".pdata"
1804 1804
1805 1805 self.optchar = "P"
1806 1806
1807 1807 self.basicHeaderObj = BasicHeader(LOCALTIME)
1808 1808
1809 1809 self.systemHeaderObj = SystemHeader()
1810 1810
1811 1811 self.radarControllerHeaderObj = RadarControllerHeader()
1812 1812
1813 1813 self.processingHeaderObj = ProcessingHeader()
1814 1814
1815 1815 self.online = 0
1816 1816
1817 1817 self.fp = None
1818 1818
1819 1819 self.idFile = None
1820 1820
1821 1821 self.dtype = None
1822 1822
1823 1823 self.fileSizeByHeader = None
1824 1824
1825 1825 self.filenameList = []
1826 1826
1827 1827 self.filename = None
1828 1828
1829 1829 self.fileSize = None
1830 1830
1831 1831 self.firstHeaderSize = 0
1832 1832
1833 1833 self.basicHeaderSize = 24
1834 1834
1835 1835 self.pathList = []
1836 1836
1837 1837 self.lastUTTime = 0
1838 1838
1839 1839 self.maxTimeStep = 30
1840 1840
1841 1841 self.flagNoMoreFiles = 0
1842 1842
1843 1843 self.set = 0
1844 1844
1845 1845 self.path = None
1846 1846
1847 1847 self.delay = 3 #seconds
1848 1848
1849 1849 self.nTries = 3 #quantity tries
1850 1850
1851 1851 self.nFiles = 3 #number of files for searching
1852 1852
1853 1853 self.nReadBlocks = 0
1854 1854
1855 1855 self.flagIsNewFile = 1
1856 1856
1857 1857 self.ippSeconds = 0
1858 1858
1859 1859 self.flagTimeBlock = 0
1860 1860
1861 1861 self.flagIsNewBlock = 0
1862 1862
1863 1863 self.nTotalBlocks = 0
1864 1864
1865 1865 self.blocksize = 0
1866 1866
1867 1867 self.dataOut = self.createObjByDefault()
1868 1868
1869 1869
1870 1870 def createObjByDefault(self):
1871 1871
1872 1872 dataObj = Spectra()
1873 1873
1874 1874 return dataObj
1875 1875
1876 1876 def __hasNotDataInBuffer(self):
1877 1877 return 1
1878 1878
1879 1879
1880 1880 def getBlockDimension(self):
1881 1881 """
1882 1882 Obtiene la cantidad de puntos a leer por cada bloque de datos
1883 1883
1884 1884 Affected:
1885 1885 self.nRdChannels
1886 1886 self.nRdPairs
1887 1887 self.pts2read_SelfSpectra
1888 1888 self.pts2read_CrossSpectra
1889 1889 self.pts2read_DCchannels
1890 1890 self.blocksize
1891 1891 self.dataOut.nChannels
1892 1892 self.dataOut.nPairs
1893 1893
1894 1894 Return:
1895 1895 None
1896 1896 """
1897 1897 self.nRdChannels = 0
1898 1898 self.nRdPairs = 0
1899 1899 self.rdPairList = []
1900 1900
1901 1901 for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
1902 1902 if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
1903 1903 self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
1904 1904 else:
1905 1905 self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
1906 1906 self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
1907 1907
1908 1908 pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
1909 1909
1910 1910 self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
1911 1911 self.blocksize = self.pts2read_SelfSpectra
1912 1912
1913 1913 if self.processingHeaderObj.flag_cspc:
1914 1914 self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
1915 1915 self.blocksize += self.pts2read_CrossSpectra
1916 1916
1917 1917 if self.processingHeaderObj.flag_dc:
1918 1918 self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
1919 1919 self.blocksize += self.pts2read_DCchannels
1920 1920
1921 1921 # self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
1922 1922
1923 1923
1924 1924 def readBlock(self):
1925 1925 """
1926 1926 Lee el bloque de datos desde la posicion actual del puntero del archivo
1927 1927 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
1928 1928 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
1929 1929 es seteado a 0
1930 1930
1931 1931 Return: None
1932 1932
1933 1933 Variables afectadas:
1934 1934
1935 1935 self.flagIsNewFile
1936 1936 self.flagIsNewBlock
1937 1937 self.nTotalBlocks
1938 1938 self.data_spc
1939 1939 self.data_cspc
1940 1940 self.data_dc
1941 1941
1942 1942 Exceptions:
1943 1943 Si un bloque leido no es un bloque valido
1944 1944 """
1945 1945 blockOk_flag = False
1946 1946 fpointer = self.fp.tell()
1947 1947
1948 1948 spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
1949 1949 spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
1950 1950
1951 1951 if self.processingHeaderObj.flag_cspc:
1952 1952 cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
1953 1953 cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
1954 1954
1955 1955 if self.processingHeaderObj.flag_dc:
1956 1956 dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
1957 1957 dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
1958 1958
1959 1959
1960 1960 if not(self.processingHeaderObj.shif_fft):
1961 1961 #desplaza a la derecha en el eje 2 determinadas posiciones
1962 1962 shift = int(self.processingHeaderObj.profilesPerBlock/2)
1963 1963 spc = numpy.roll( spc, shift , axis=2 )
1964 1964
1965 1965 if self.processingHeaderObj.flag_cspc:
1966 1966 #desplaza a la derecha en el eje 2 determinadas posiciones
1967 1967 cspc = numpy.roll( cspc, shift, axis=2 )
1968 1968
1969 self.processingHeaderObj.shif_fft = True
1969 # self.processingHeaderObj.shif_fft = True
1970 1970
1971 1971 spc = numpy.transpose( spc, (0,2,1) )
1972 1972 self.data_spc = spc
1973 1973
1974 1974 if self.processingHeaderObj.flag_cspc:
1975 1975 cspc = numpy.transpose( cspc, (0,2,1) )
1976 1976 self.data_cspc = cspc['real'] + cspc['imag']*1j
1977 1977 else:
1978 1978 self.data_cspc = None
1979 1979
1980 1980 if self.processingHeaderObj.flag_dc:
1981 1981 self.data_dc = dc['real'] + dc['imag']*1j
1982 1982 else:
1983 1983 self.data_dc = None
1984 1984
1985 1985 self.flagIsNewFile = 0
1986 1986 self.flagIsNewBlock = 1
1987 1987
1988 1988 self.nTotalBlocks += 1
1989 1989 self.nReadBlocks += 1
1990 1990
1991 1991 return 1
1992 1992
1993 1993
1994 1994 def getData(self):
1995 1995 """
1996 1996 Copia el buffer de lectura a la clase "Spectra",
1997 1997 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1998 1998 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
1999 1999
2000 2000 Return:
2001 2001 0 : Si no hay mas archivos disponibles
2002 2002 1 : Si hizo una buena copia del buffer
2003 2003
2004 2004 Affected:
2005 2005 self.dataOut
2006 2006
2007 2007 self.flagTimeBlock
2008 2008 self.flagIsNewBlock
2009 2009 """
2010 2010
2011 2011 if self.flagNoMoreFiles:
2012 2012 self.dataOut.flagNoData = True
2013 2013 print 'Process finished'
2014 2014 return 0
2015 2015
2016 2016 self.flagTimeBlock = 0
2017 2017 self.flagIsNewBlock = 0
2018 2018
2019 2019 if self.__hasNotDataInBuffer():
2020 2020
2021 2021 if not( self.readNextBlock() ):
2022 2022 self.dataOut.flagNoData = True
2023 2023 return 0
2024 2024
2025 2025 # self.updateDataHeader()
2026 2026
2027 2027 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
2028 2028
2029 2029 if self.data_dc == None:
2030 2030 self.dataOut.flagNoData = True
2031 2031 return 0
2032 2032
2033 2033 self.dataOut.data_spc = self.data_spc
2034 2034
2035 2035 self.dataOut.data_cspc = self.data_cspc
2036 2036
2037 2037 self.dataOut.data_dc = self.data_dc
2038 2038
2039 2039 self.dataOut.flagTimeBlock = self.flagTimeBlock
2040 2040
2041 2041 self.dataOut.flagNoData = False
2042 2042
2043 self.dataOut.dtype = self.dtype
2043 self.dataOut.dtype = numpy.dtype([('real','<f8'),('imag','<f8')])#self.dtype
2044 2044
2045 2045 # self.dataOut.nChannels = self.nRdChannels
2046 2046
2047 2047 self.dataOut.nPairs = self.nRdPairs
2048 2048
2049 2049 self.dataOut.pairsList = self.rdPairList
2050 2050
2051 2051 # self.dataOut.nHeights = self.processingHeaderObj.nHeights
2052 2052
2053 2053 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
2054 2054
2055 2055 self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
2056 2056
2057 2057 self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
2058 2058
2059 2059 self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
2060 2060
2061 2061 xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
2062 2062
2063 2063 self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
2064 2064
2065 2065 self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
2066 2066
2067 2067 # self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
2068 2068
2069 2069 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
2070 2070
2071 2071 self.dataOut.ippSeconds = self.ippSeconds
2072 2072
2073 2073 self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints
2074 2074
2075 2075 # self.profileIndex += 1
2076 2076
2077 2077 self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
2078 2078
2079 2079 self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
2080 2080
2081 2081 self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
2082 2082
2083 2083 self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada
2084 2084
2085 2085 self.dataOut.flagDeflipData = True #asumo q la data no esta sin flip
2086 2086
2087 2087 if self.processingHeaderObj.code != None:
2088 2088
2089 2089 self.dataOut.nCode = self.processingHeaderObj.nCode
2090 2090
2091 2091 self.dataOut.nBaud = self.processingHeaderObj.nBaud
2092 2092
2093 2093 self.dataOut.code = self.processingHeaderObj.code
2094 2094
2095 2095 self.dataOut.flagDecodeData = True
2096 2096
2097 2097 return self.dataOut.data_spc
2098 2098
2099 2099
2100 2100 class SpectraWriter(JRODataWriter):
2101 2101
2102 2102 """
2103 2103 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
2104 2104 de los datos siempre se realiza por bloques.
2105 2105 """
2106 2106
2107 2107 ext = ".pdata"
2108 2108
2109 2109 optchar = "P"
2110 2110
2111 2111 shape_spc_Buffer = None
2112 2112
2113 2113 shape_cspc_Buffer = None
2114 2114
2115 2115 shape_dc_Buffer = None
2116 2116
2117 2117 data_spc = None
2118 2118
2119 2119 data_cspc = None
2120 2120
2121 2121 data_dc = None
2122 2122
2123 2123 # dataOut = None
2124 2124
2125 2125 def __init__(self):
2126 2126 """
2127 2127 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
2128 2128
2129 2129 Affected:
2130 2130 self.dataOut
2131 2131 self.basicHeaderObj
2132 2132 self.systemHeaderObj
2133 2133 self.radarControllerHeaderObj
2134 2134 self.processingHeaderObj
2135 2135
2136 2136 Return: None
2137 2137 """
2138 2138
2139 2139 self.isConfig = False
2140 2140
2141 2141 self.nTotalBlocks = 0
2142 2142
2143 2143 self.data_spc = None
2144 2144
2145 2145 self.data_cspc = None
2146 2146
2147 2147 self.data_dc = None
2148 2148
2149 2149 self.fp = None
2150 2150
2151 2151 self.flagIsNewFile = 1
2152 2152
2153 2153 self.nTotalBlocks = 0
2154 2154
2155 2155 self.flagIsNewBlock = 0
2156 2156
2157 2157 self.setFile = None
2158 2158
2159 2159 self.dtype = None
2160 2160
2161 2161 self.path = None
2162 2162
2163 2163 self.noMoreFiles = 0
2164 2164
2165 2165 self.filename = None
2166 2166
2167 2167 self.basicHeaderObj = BasicHeader(LOCALTIME)
2168 2168
2169 2169 self.systemHeaderObj = SystemHeader()
2170 2170
2171 2171 self.radarControllerHeaderObj = RadarControllerHeader()
2172 2172
2173 2173 self.processingHeaderObj = ProcessingHeader()
2174 2174
2175 2175
2176 2176 def hasAllDataInBuffer(self):
2177 2177 return 1
2178 2178
2179 2179
2180 2180 def setBlockDimension(self):
2181 2181 """
2182 2182 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
2183 2183
2184 2184 Affected:
2185 2185 self.shape_spc_Buffer
2186 2186 self.shape_cspc_Buffer
2187 2187 self.shape_dc_Buffer
2188 2188
2189 2189 Return: None
2190 2190 """
2191 2191 self.shape_spc_Buffer = (self.dataOut.nChannels,
2192 2192 self.processingHeaderObj.nHeights,
2193 2193 self.processingHeaderObj.profilesPerBlock)
2194 2194
2195 2195 self.shape_cspc_Buffer = (self.dataOut.nPairs,
2196 2196 self.processingHeaderObj.nHeights,
2197 2197 self.processingHeaderObj.profilesPerBlock)
2198 2198
2199 2199 self.shape_dc_Buffer = (self.dataOut.nChannels,
2200 2200 self.processingHeaderObj.nHeights)
2201 2201
2202 2202
2203 2203 def writeBlock(self):
2204 2204 """
2205 2205 Escribe el buffer en el file designado
2206 2206
2207 2207 Affected:
2208 2208 self.data_spc
2209 2209 self.data_cspc
2210 2210 self.data_dc
2211 2211 self.flagIsNewFile
2212 2212 self.flagIsNewBlock
2213 2213 self.nTotalBlocks
2214 2214 self.nWriteBlocks
2215 2215
2216 2216 Return: None
2217 2217 """
2218 2218
2219 2219 spc = numpy.transpose( self.data_spc, (0,2,1) )
2220 2220 if not( self.processingHeaderObj.shif_fft ):
2221 2221 spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
2222 2222 data = spc.reshape((-1))
2223 2223 data.tofile(self.fp)
2224 2224
2225 2225 if self.data_cspc != None:
2226 2226 data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )
2227 2227 cspc = numpy.transpose( self.data_cspc, (0,2,1) )
2228 2228 if not( self.processingHeaderObj.shif_fft ):
2229 2229 cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
2230 2230 data['real'] = cspc.real
2231 2231 data['imag'] = cspc.imag
2232 2232 data = data.reshape((-1))
2233 2233 data.tofile(self.fp)
2234 2234
2235 2235 if self.data_dc != None:
2236 2236 data = numpy.zeros( self.shape_dc_Buffer, self.dtype )
2237 2237 dc = self.data_dc
2238 2238 data['real'] = dc.real
2239 2239 data['imag'] = dc.imag
2240 2240 data = data.reshape((-1))
2241 2241 data.tofile(self.fp)
2242 2242
2243 2243 self.data_spc.fill(0)
2244 2244 self.data_dc.fill(0)
2245 2245 if self.data_cspc != None:
2246 2246 self.data_cspc.fill(0)
2247 2247
2248 2248 self.flagIsNewFile = 0
2249 2249 self.flagIsNewBlock = 1
2250 2250 self.nTotalBlocks += 1
2251 2251 self.nWriteBlocks += 1
2252 2252 self.blockIndex += 1
2253 2253
2254 2254
2255 2255 def putData(self):
2256 2256 """
2257 2257 Setea un bloque de datos y luego los escribe en un file
2258 2258
2259 2259 Affected:
2260 2260 self.data_spc
2261 2261 self.data_cspc
2262 2262 self.data_dc
2263 2263
2264 2264 Return:
2265 2265 0 : Si no hay data o no hay mas files que puedan escribirse
2266 2266 1 : Si se escribio la data de un bloque en un file
2267 2267 """
2268 2268
2269 2269 if self.dataOut.flagNoData:
2270 2270 return 0
2271 2271
2272 2272 self.flagIsNewBlock = 0
2273 2273
2274 2274 if self.dataOut.flagTimeBlock:
2275 2275 self.data_spc.fill(0)
2276 2276 self.data_cspc.fill(0)
2277 2277 self.data_dc.fill(0)
2278 2278 self.setNextFile()
2279 2279
2280 2280 if self.flagIsNewFile == 0:
2281 2281 self.getBasicHeader()
2282 2282
2283 self.data_spc = self.dataOut.data_spc
2284 self.data_cspc = self.dataOut.data_cspc
2285 self.data_dc = self.dataOut.data_dc
2283 self.data_spc = self.dataOut.data_spc.copy()
2284 self.data_cspc = self.dataOut.data_cspc.copy()
2285 self.data_dc = self.dataOut.data_dc.copy()
2286 2286
2287 2287 # #self.processingHeaderObj.dataBlocksPerFile)
2288 2288 if self.hasAllDataInBuffer():
2289 2289 # self.getDataHeader()
2290 2290 self.writeNextBlock()
2291 2291
2292 2292 return 1
2293 2293
2294 2294
2295 2295 def __getProcessFlags(self):
2296 2296
2297 2297 processFlags = 0
2298 2298
2299 2299 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
2300 2300 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
2301 2301 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
2302 2302 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
2303 2303 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
2304 2304 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
2305 2305
2306 2306 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
2307 2307
2308 2308
2309 2309
2310 2310 datatypeValueList = [PROCFLAG.DATATYPE_CHAR,
2311 2311 PROCFLAG.DATATYPE_SHORT,
2312 2312 PROCFLAG.DATATYPE_LONG,
2313 2313 PROCFLAG.DATATYPE_INT64,
2314 2314 PROCFLAG.DATATYPE_FLOAT,
2315 2315 PROCFLAG.DATATYPE_DOUBLE]
2316 2316
2317 2317
2318 2318 for index in range(len(dtypeList)):
2319 2319 if self.dataOut.dtype == dtypeList[index]:
2320 2320 dtypeValue = datatypeValueList[index]
2321 2321 break
2322 2322
2323 2323 processFlags += dtypeValue
2324 2324
2325 2325 if self.dataOut.flagDecodeData:
2326 2326 processFlags += PROCFLAG.DECODE_DATA
2327 2327
2328 2328 if self.dataOut.flagDeflipData:
2329 2329 processFlags += PROCFLAG.DEFLIP_DATA
2330 2330
2331 2331 if self.dataOut.code != None:
2332 2332 processFlags += PROCFLAG.DEFINE_PROCESS_CODE
2333 2333
2334 2334 if self.dataOut.nIncohInt > 1:
2335 2335 processFlags += PROCFLAG.INCOHERENT_INTEGRATION
2336 2336
2337 2337 if self.dataOut.data_dc != None:
2338 2338 processFlags += PROCFLAG.SAVE_CHANNELS_DC
2339 2339
2340 2340 return processFlags
2341 2341
2342 2342
2343 2343 def __getBlockSize(self):
2344 2344 '''
2345 2345 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
2346 2346 '''
2347 2347
2348 2348 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
2349 2349 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
2350 2350 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
2351 2351 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
2352 2352 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
2353 2353 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
2354 2354
2355 2355 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
2356 2356 datatypeValueList = [1,2,4,8,4,8]
2357 2357 for index in range(len(dtypeList)):
2358 2358 if self.dataOut.dtype == dtypeList[index]:
2359 2359 datatypeValue = datatypeValueList[index]
2360 2360 break
2361 2361
2362 2362
2363 2363 pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
2364 2364
2365 2365 pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
2366 2366 blocksize = (pts2write_SelfSpectra*datatypeValue)
2367 2367
2368 2368 if self.dataOut.data_cspc != None:
2369 2369 pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
2370 2370 blocksize += (pts2write_CrossSpectra*datatypeValue*2)
2371 2371
2372 2372 if self.dataOut.data_dc != None:
2373 2373 pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
2374 2374 blocksize += (pts2write_DCchannels*datatypeValue*2)
2375 2375
2376 2376 blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
2377 2377
2378 2378 return blocksize
2379 2379
2380 2380 def getDataHeader(self):
2381 2381
2382 2382 """
2383 2383 Obtiene una copia del First Header
2384 2384
2385 2385 Affected:
2386 2386 self.systemHeaderObj
2387 2387 self.radarControllerHeaderObj
2388 2388 self.dtype
2389 2389
2390 2390 Return:
2391 2391 None
2392 2392 """
2393 2393
2394 2394 self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
2395 2395 self.systemHeaderObj.nChannels = self.dataOut.nChannels
2396 2396 self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
2397 2397
2398 2398 self.getBasicHeader()
2399 2399
2400 2400 processingHeaderSize = 40 # bytes
2401 2401 self.processingHeaderObj.dtype = 0 # Voltage
2402 2402 self.processingHeaderObj.blockSize = self.__getBlockSize()
2403 2403 self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
2404 2404 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
2405 2405 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
2406 2406 self.processingHeaderObj.processFlags = self.__getProcessFlags()
2407 2407 self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
2408 2408 self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
2409 2409 self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
2410 2410
2411 2411 if self.processingHeaderObj.totalSpectra > 0:
2412 2412 channelList = []
2413 2413 for channel in range(self.dataOut.nChannels):
2414 2414 channelList.append(channel)
2415 2415 channelList.append(channel)
2416 2416
2417 2417 pairsList = []
2418 2418 for pair in self.dataOut.pairsList:
2419 2419 pairsList.append(pair[0])
2420 2420 pairsList.append(pair[1])
2421 2421 spectraComb = channelList + pairsList
2422 2422 spectraComb = numpy.array(spectraComb,dtype="u1")
2423 2423 self.processingHeaderObj.spectraComb = spectraComb
2424 2424 sizeOfSpcComb = len(spectraComb)
2425 2425 processingHeaderSize += sizeOfSpcComb
2426 2426
2427 2427 if self.dataOut.code != None:
2428 2428 self.processingHeaderObj.code = self.dataOut.code
2429 2429 self.processingHeaderObj.nCode = self.dataOut.nCode
2430 2430 self.processingHeaderObj.nBaud = self.dataOut.nBaud
2431 2431 nCodeSize = 4 # bytes
2432 2432 nBaudSize = 4 # bytes
2433 2433 codeSize = 4 # bytes
2434 2434 sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOut.nCode * self.dataOut.nBaud)
2435 2435 processingHeaderSize += sizeOfCode
2436 2436
2437 2437 if self.processingHeaderObj.nWindows != 0:
2438 2438 self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
2439 2439 self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
2440 2440 self.processingHeaderObj.nHeights = self.dataOut.nHeights
2441 2441 self.processingHeaderObj.samplesWin = self.dataOut.nHeights
2442 2442 sizeOfFirstHeight = 4
2443 2443 sizeOfdeltaHeight = 4
2444 2444 sizeOfnHeights = 4
2445 2445 sizeOfWindows = (sizeOfFirstHeight + sizeOfdeltaHeight + sizeOfnHeights)*self.processingHeaderObj.nWindows
2446 2446 processingHeaderSize += sizeOfWindows
2447 2447
2448 2448 self.processingHeaderObj.size = processingHeaderSize
2449 2449
2450 2450 class SpectraHeisWriter():
2451 2451
2452 2452 i=0
2453 2453
2454 2454 def __init__(self, dataOut):
2455 2455
2456 2456 self.wrObj = FITS()
2457 2457 self.dataOut = dataOut
2458 2458
2459 2459 def isNumber(str):
2460 2460 """
2461 2461 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
2462 2462
2463 2463 Excepciones:
2464 2464 Si un determinado string no puede ser convertido a numero
2465 2465 Input:
2466 2466 str, string al cual se le analiza para determinar si convertible a un numero o no
2467 2467
2468 2468 Return:
2469 2469 True : si el string es uno numerico
2470 2470 False : no es un string numerico
2471 2471 """
2472 2472 try:
2473 2473 float( str )
2474 2474 return True
2475 2475 except:
2476 2476 return False
2477 2477
2478 2478 def setup(self, wrpath,):
2479 2479
2480 2480 if not(os.path.exists(wrpath)):
2481 2481 os.mkdir(wrpath)
2482 2482
2483 2483 self.wrpath = wrpath
2484 2484 self.setFile = 0
2485 2485
2486 2486 def putData(self):
2487 2487 # self.wrObj.writeHeader(nChannels=self.dataOut.nChannels, nFFTPoints=self.dataOut.nFFTPoints)
2488 2488 #name = self.dataOut.utctime
2489 2489 name= time.localtime( self.dataOut.utctime)
2490 2490 ext=".fits"
2491 2491 #folder='D%4.4d%3.3d'%(name.tm_year,name.tm_yday)
2492 2492 subfolder = 'D%4.4d%3.3d' % (name.tm_year,name.tm_yday)
2493 2493
2494 2494 fullpath = os.path.join( self.wrpath, subfolder )
2495 2495 if not( os.path.exists(fullpath) ):
2496 2496 os.mkdir(fullpath)
2497 2497 self.setFile += 1
2498 2498 file = 'D%4.4d%3.3d%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
2499 2499
2500 2500 filename = os.path.join(self.wrpath,subfolder, file)
2501 2501
2502 2502 # print self.dataOut.ippSeconds
2503 2503 freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)/(2*self.dataOut.ippSeconds)
2504 2504
2505 2505 col1=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
2506 2506 col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[0,:]))
2507 2507 col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[1,:]))
2508 2508 col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[2,:]))
2509 2509 col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[3,:]))
2510 2510 col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[4,:]))
2511 2511 col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[5,:]))
2512 2512 col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[6,:]))
2513 2513 col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[7,:]))
2514 2514 #n=numpy.arange((100))
2515 2515 n=self.dataOut.data_spc[6,:]
2516 2516 a=self.wrObj.cFImage(n)
2517 2517 b=self.wrObj.Ctable(col1,col2,col3,col4,col5,col6,col7,col8,col9)
2518 2518 self.wrObj.CFile(a,b)
2519 2519 self.wrObj.wFile(filename)
2520 2520 return 1
2521 2521
2522 2522 class FITS:
2523 2523
2524 2524 name=None
2525 2525 format=None
2526 2526 array =None
2527 2527 data =None
2528 2528 thdulist=None
2529 2529
2530 2530 def __init__(self):
2531 2531
2532 2532 pass
2533 2533
2534 2534 def setColF(self,name,format,array):
2535 2535 self.name=name
2536 2536 self.format=format
2537 2537 self.array=array
2538 2538 a1=numpy.array([self.array],dtype=numpy.float32)
2539 2539 self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
2540 2540 return self.col1
2541 2541
2542 2542 # def setColP(self,name,format,data):
2543 2543 # self.name=name
2544 2544 # self.format=format
2545 2545 # self.data=data
2546 2546 # a2=numpy.array([self.data],dtype=numpy.float32)
2547 2547 # self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
2548 2548 # return self.col2
2549 2549
2550 2550 def writeHeader(self,):
2551 2551 pass
2552 2552
2553 2553 def writeData(self,name,format,data):
2554 2554 self.name=name
2555 2555 self.format=format
2556 2556 self.data=data
2557 2557 a2=numpy.array([self.data],dtype=numpy.float32)
2558 2558 self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
2559 2559 return self.col2
2560 2560
2561 2561 def cFImage(self,n):
2562 2562 self.hdu= pyfits.PrimaryHDU(n)
2563 2563 return self.hdu
2564 2564
2565 2565 def Ctable(self,col1,col2,col3,col4,col5,col6,col7,col8,col9):
2566 2566 self.cols=pyfits.ColDefs( [col1,col2,col3,col4,col5,col6,col7,col8,col9])
2567 2567 self.tbhdu = pyfits.new_table(self.cols)
2568 2568 return self.tbhdu
2569 2569
2570 2570 def CFile(self,hdu,tbhdu):
2571 2571 self.thdulist=pyfits.HDUList([hdu,tbhdu])
2572 2572
2573 2573 def wFile(self,filename):
2574 2574 self.thdulist.writeto(filename) No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,526 +1,528
1 1 '''
2 2
3 3 $Author: murco $
4 4 $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
5 5 '''
6 6 import sys
7 7 import numpy
8 8 import copy
9 9 import datetime
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 def printInfo(self):
26 26
27 27 for key in self.__dict__.keys():
28 28 print "%s = %s" %(key, self.__dict__[key])
29 29
30 30 class BasicHeader(Header):
31 31
32 32 size = None
33 33 version = None
34 34 dataBlock = None
35 35 utc = None
36 36 miliSecond = None
37 37 timeZone = None
38 38 dstFlag = None
39 39 errorCount = None
40 40 struct = None
41 41 datatime = None
42 42
43 43 __LOCALTIME = None
44 44
45 45 def __init__(self, localtime=0):
46 46
47 47 self.size = 0
48 48 self.version = 0
49 49 self.dataBlock = 0
50 50 self.utc = 0
51 51 self.miliSecond = 0
52 52 self.timeZone = 0
53 53 self.dstFlag = 0
54 54 self.errorCount = 0
55 55 self.struct = numpy.dtype([
56 56 ('nSize','<u4'),
57 57 ('nVersion','<u2'),
58 58 ('nDataBlockId','<u4'),
59 59 ('nUtime','<u4'),
60 60 ('nMilsec','<u2'),
61 61 ('nTimezone','<i2'),
62 62 ('nDstflag','<i2'),
63 63 ('nErrorCount','<u4')
64 64 ])
65 65
66 66 self.__LOCALTIME = localtime
67 67
68 68 def read(self, fp):
69 69 try:
70 70 header = numpy.fromfile(fp, self.struct,1)
71 71 self.size = int(header['nSize'][0])
72 72 self.version = int(header['nVersion'][0])
73 73 self.dataBlock = int(header['nDataBlockId'][0])
74 74 self.utc = int(header['nUtime'][0])
75 75 self.miliSecond = int(header['nMilsec'][0])
76 76 self.timeZone = int(header['nTimezone'][0])
77 77 self.dstFlag = int(header['nDstflag'][0])
78 78 self.errorCount = int(header['nErrorCount'][0])
79 79
80 80 self.utc += self.__LOCALTIME
81 81
82 82 self.datatime = datetime.datetime.utcfromtimestamp(self.utc)
83 83
84 84 except Exception, e:
85 85 print "BasicHeader: "
86 86 print e
87 87 return 0
88 88
89 89 return 1
90 90
91 91 def write(self, fp):
92 self.utc -= self.__LOCALTIME
92 93 headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
93 94 header = numpy.array(headerTuple,self.struct)
94 95 header.tofile(fp)
95 96
96 97 return 1
97 98
98 99 class SystemHeader(Header):
99 100
100 101 size = None
101 102 nSamples = None
102 103 nProfiles = None
103 104 nChannels = None
104 105 adcResolution = None
105 106 pciDioBusWidth = None
106 107 struct = None
107 108
108 109 def __init__(self):
109 110 self.size = 0
110 111 self.nSamples = 0
111 112 self.nProfiles = 0
112 113 self.nChannels = 0
113 114 self.adcResolution = 0
114 115 self.pciDioBusWidth = 0
115 116 self.struct = numpy.dtype([
116 117 ('nSize','<u4'),
117 118 ('nNumSamples','<u4'),
118 119 ('nNumProfiles','<u4'),
119 120 ('nNumChannels','<u4'),
120 121 ('nADCResolution','<u4'),
121 122 ('nPCDIOBusWidth','<u4'),
122 123 ])
123 124
124 125
125 126 def read(self, fp):
126 127 try:
127 128 header = numpy.fromfile(fp,self.struct,1)
128 129 self.size = header['nSize'][0]
129 130 self.nSamples = header['nNumSamples'][0]
130 131 self.nProfiles = header['nNumProfiles'][0]
131 132 self.nChannels = header['nNumChannels'][0]
132 133 self.adcResolution = header['nADCResolution'][0]
133 134 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
134 135
135 136 except Exception, e:
136 137 print "SystemHeader: " + e
137 138 return 0
138 139
139 140 return 1
140 141
141 142 def write(self, fp):
142 143 headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
143 144 header = numpy.array(headerTuple,self.struct)
144 145 header.tofile(fp)
145 146
146 147 return 1
147 148
148 149 class RadarControllerHeader(Header):
149 150
150 151 size = None
151 152 expType = None
152 153 nTx = None
153 154 ipp = None
154 155 txA = None
155 156 txB = None
156 157 nWindows = None
157 158 numTaus = None
158 159 codeType = None
159 160 line6Function = None
160 161 line5Function = None
161 162 fClock = None
162 163 prePulseBefore = None
163 164 prePulserAfter = None
164 165 rangeIpp = None
165 166 rangeTxA = None
166 167 rangeTxB = None
167 168 struct = None
168 169
169 170 def __init__(self):
170 171 self.size = 0
171 172 self.expType = 0
172 173 self.nTx = 0
173 174 self.ipp = 0
174 175 self.txA = 0
175 176 self.txB = 0
176 177 self.nWindows = 0
177 178 self.numTaus = 0
178 179 self.codeType = 0
179 180 self.line6Function = 0
180 181 self.line5Function = 0
181 182 self.fClock = 0
182 183 self.prePulseBefore = 0
183 184 self.prePulserAfter = 0
184 185 self.rangeIpp = 0
185 186 self.rangeTxA = 0
186 187 self.rangeTxB = 0
187 188 self.struct = numpy.dtype([
188 189 ('nSize','<u4'),
189 190 ('nExpType','<u4'),
190 191 ('nNTx','<u4'),
191 192 ('fIpp','<f4'),
192 193 ('fTxA','<f4'),
193 194 ('fTxB','<f4'),
194 195 ('nNumWindows','<u4'),
195 196 ('nNumTaus','<u4'),
196 197 ('nCodeType','<u4'),
197 198 ('nLine6Function','<u4'),
198 199 ('nLine5Function','<u4'),
199 200 ('fClock','<f4'),
200 201 ('nPrePulseBefore','<u4'),
201 202 ('nPrePulseAfter','<u4'),
202 203 ('sRangeIPP','<a20'),
203 204 ('sRangeTxA','<a20'),
204 205 ('sRangeTxB','<a20'),
205 206 ])
206 207
207 208 self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
208 209
209 210 self.samplingWindow = None
210 211 self.nHeights = None
211 212 self.firstHeight = None
212 213 self.deltaHeight = None
213 214 self.samplesWin = None
214 215
215 216 self.nCode = None
216 217 self.nBaud = None
217 218 self.code = None
218 219 self.flip1 = None
219 220 self.flip2 = None
220 221
221 222 self.dynamic = numpy.array([],numpy.dtype('byte'))
222 223
223 224
224 225 def read(self, fp):
225 226 try:
226 227 startFp = fp.tell()
227 228 header = numpy.fromfile(fp,self.struct,1)
228 229 self.size = int(header['nSize'][0])
229 230 self.expType = int(header['nExpType'][0])
230 231 self.nTx = int(header['nNTx'][0])
231 232 self.ipp = float(header['fIpp'][0])
232 233 self.txA = float(header['fTxA'][0])
233 234 self.txB = float(header['fTxB'][0])
234 235 self.nWindows = int(header['nNumWindows'][0])
235 236 self.numTaus = int(header['nNumTaus'][0])
236 237 self.codeType = int(header['nCodeType'][0])
237 238 self.line6Function = int(header['nLine6Function'][0])
238 239 self.line5Function = int(header['nLine5Function'][0])
239 240 self.fClock = float(header['fClock'][0])
240 241 self.prePulseBefore = int(header['nPrePulseBefore'][0])
241 242 self.prePulserAfter = int(header['nPrePulseAfter'][0])
242 243 self.rangeIpp = header['sRangeIPP'][0]
243 244 self.rangeTxA = header['sRangeTxA'][0]
244 245 self.rangeTxB = header['sRangeTxB'][0]
245 246 # jump Dynamic Radar Controller Header
246 247 jumpFp = self.size - 116
247 248 self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
248 249 #pointer backward to dynamic header and read
249 250 backFp = fp.tell() - jumpFp
250 251 fp.seek(backFp)
251 252
252 253 self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
253 254 self.nHeights = int(numpy.sum(self.samplingWindow['nsa']))
254 255 self.firstHeight = self.samplingWindow['h0']
255 256 self.deltaHeight = self.samplingWindow['dh']
256 257 self.samplesWin = self.samplingWindow['nsa']
257 258
258 259 self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
259 260
260 261 if self.codeType != 0:
261 262 self.nCode = int(numpy.fromfile(fp,'<u4',1))
262 263 self.nBaud = int(numpy.fromfile(fp,'<u4',1))
263 264 self.code = numpy.empty([self.nCode,self.nBaud],dtype='u1')
264 265 tempList = []
265 266 for ic in range(self.nCode):
266 267 temp = numpy.fromfile(fp,'u1',4*int(numpy.ceil(self.nBaud/32.)))
267 268 tempList.append(temp)
268 269 self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.nBaud:]
269 270 self.code = 2.0*self.code - 1.0
270 271
271 272 if self.line5Function == RCfunction.FLIP:
272 273 self.flip1 = numpy.fromfile(fp,'<u4',1)
273 274
274 275 if self.line6Function == RCfunction.FLIP:
275 276 self.flip2 = numpy.fromfile(fp,'<u4',1)
276 277
277 278 endFp = self.size + startFp
278 279 jumpFp = endFp - fp.tell()
279 280 if jumpFp > 0:
280 281 fp.seek(jumpFp)
281 282
282 283 except Exception, e:
283 284 print "RadarControllerHeader: " + e
284 285 return 0
285 286
286 287 return 1
287 288
288 289 def write(self, fp):
289 290 headerTuple = (self.size,
290 291 self.expType,
291 292 self.nTx,
292 293 self.ipp,
293 294 self.txA,
294 295 self.txB,
295 296 self.nWindows,
296 297 self.numTaus,
297 298 self.codeType,
298 299 self.line6Function,
299 300 self.line5Function,
300 301 self.fClock,
301 302 self.prePulseBefore,
302 303 self.prePulserAfter,
303 304 self.rangeIpp,
304 305 self.rangeTxA,
305 306 self.rangeTxB)
306 307
307 308 header = numpy.array(headerTuple,self.struct)
308 309 header.tofile(fp)
309 310
310 311 dynamic = self.dynamic
311 312 dynamic.tofile(fp)
312 313
313 314 return 1
314 315
315 316
316 317
317 318 class ProcessingHeader(Header):
318 319
319 320 size = None
320 321 dtype = None
321 322 blockSize = None
322 323 profilesPerBlock = None
323 324 dataBlocksPerFile = None
324 325 nWindows = None
325 326 processFlags = None
326 327 nCohInt = None
327 328 nIncohInt = None
328 329 totalSpectra = None
329 330 struct = None
330 331 flag_dc = None
331 332 flag_cspc = None
332 333
333 334 def __init__(self):
334 335 self.size = 0
335 336 self.dtype = 0
336 337 self.blockSize = 0
337 338 self.profilesPerBlock = 0
338 339 self.dataBlocksPerFile = 0
339 340 self.nWindows = 0
340 341 self.processFlags = 0
341 342 self.nCohInt = 0
342 343 self.nIncohInt = 0
343 344 self.totalSpectra = 0
344 345 self.struct = numpy.dtype([
345 346 ('nSize','<u4'),
346 347 ('nDataType','<u4'),
347 348 ('nSizeOfDataBlock','<u4'),
348 349 ('nProfilesperBlock','<u4'),
349 350 ('nDataBlocksperFile','<u4'),
350 351 ('nNumWindows','<u4'),
351 352 ('nProcessFlags','<u4'),
352 353 ('nCoherentIntegrations','<u4'),
353 354 ('nIncoherentIntegrations','<u4'),
354 355 ('nTotalSpectra','<u4')
355 356 ])
356 357 self.samplingWindow = 0
357 358 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
358 359 self.nHeights = 0
359 360 self.firstHeight = 0
360 361 self.deltaHeight = 0
361 362 self.samplesWin = 0
362 363 self.spectraComb = 0
363 364 self.nCode = None
364 365 self.code = None
365 366 self.nBaud = None
366 367 self.shif_fft = False
367 368 self.flag_dc = False
368 369 self.flag_cspc = False
369 370
370 371 def read(self, fp):
371 372 try:
372 373 header = numpy.fromfile(fp,self.struct,1)
373 374 self.size = int(header['nSize'][0])
374 375 self.dtype = int(header['nDataType'][0])
375 376 self.blockSize = int(header['nSizeOfDataBlock'][0])
376 377 self.profilesPerBlock = int(header['nProfilesperBlock'][0])
377 378 self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
378 379 self.nWindows = int(header['nNumWindows'][0])
379 380 self.processFlags = header['nProcessFlags']
380 381 self.nCohInt = int(header['nCoherentIntegrations'][0])
381 382 self.nIncohInt = int(header['nIncoherentIntegrations'][0])
382 383 self.totalSpectra = int(header['nTotalSpectra'][0])
383 384 self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
384 385 self.nHeights = int(numpy.sum(self.samplingWindow['nsa']))
385 386 self.firstHeight = float(self.samplingWindow['h0'][0])
386 387 self.deltaHeight = float(self.samplingWindow['dh'][0])
387 388 self.samplesWin = self.samplingWindow['nsa']
388 389 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
389 390
390 391 if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
391 392 self.nCode = int(numpy.fromfile(fp,'<u4',1))
392 393 self.nBaud = int(numpy.fromfile(fp,'<u4',1))
393 self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nBaud,self.nCode)
394 self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nCode,self.nBaud)
394 395
395 396 if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
396 397 self.shif_fft = True
397 398 else:
398 399 self.shif_fft = False
399 400
400 401 if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
401 402 self.flag_dc = True
402 403
403 404 nChannels = 0
404 405 nPairs = 0
405 406 pairList = []
406 407
407 408 for i in range( 0, self.totalSpectra*2, 2 ):
408 409 if self.spectraComb[i] == self.spectraComb[i+1]:
409 410 nChannels = nChannels + 1 #par de canales iguales
410 411 else:
411 412 nPairs = nPairs + 1 #par de canales diferentes
412 413 pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
413 414
414 415 self.flag_cspc = False
415 416 if nPairs > 0:
416 417 self.flag_cspc = True
417 418
418 419 except Exception, e:
419 420 print "ProcessingHeader: " + e
420 421 return 0
421 422
422 423 return 1
423 424
424 425 def write(self, fp):
425 426 headerTuple = (self.size,
426 427 self.dtype,
427 428 self.blockSize,
428 429 self.profilesPerBlock,
429 430 self.dataBlocksPerFile,
430 431 self.nWindows,
431 432 self.processFlags,
432 433 self.nCohInt,
433 434 self.nIncohInt,
434 435 self.totalSpectra)
435 436
436 437 header = numpy.array(headerTuple,self.struct)
437 438 header.tofile(fp)
438 439
439 440 if self.nWindows != 0:
440 441 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
441 442 samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
442 443 samplingWindow.tofile(fp)
443 444
444 445
445 446 if self.totalSpectra != 0:
446 447 spectraComb = numpy.array([],numpy.dtype('u1'))
447 448 spectraComb = self.spectraComb
448 449 spectraComb.tofile(fp)
449 450
450 451
451 452 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
452 nCode = self.nCode #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
453 nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
453 454 nCode.tofile(fp)
454 455
455 nBaud = self.nBaud
456 nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
456 457 nBaud.tofile(fp)
457 458
458 code = self.code.reshape(nCode*nBaud)
459 code = self.code.reshape(self.nCode*self.nBaud)
460 code = code.astype(numpy.dtype('<f4'))
459 461 code.tofile(fp)
460 462
461 463 return 1
462 464
463 465 class RCfunction:
464 466 NONE=0
465 467 FLIP=1
466 468 CODE=2
467 469 SAMPLING=3
468 470 LIN6DIV256=4
469 471 SYNCHRO=5
470 472
471 473 class nCodeType:
472 474 NONE=0
473 475 USERDEFINE=1
474 476 BARKER2=2
475 477 BARKER3=3
476 478 BARKER4=4
477 479 BARKER5=5
478 480 BARKER7=6
479 481 BARKER11=7
480 482 BARKER13=8
481 483 AC128=9
482 484 COMPLEMENTARYCODE2=10
483 485 COMPLEMENTARYCODE4=11
484 486 COMPLEMENTARYCODE8=12
485 487 COMPLEMENTARYCODE16=13
486 488 COMPLEMENTARYCODE32=14
487 489 COMPLEMENTARYCODE64=15
488 490 COMPLEMENTARYCODE128=16
489 491 CODE_BINARY28=17
490 492
491 493 class PROCFLAG:
492 494 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
493 495 DECODE_DATA = numpy.uint32(0x00000002)
494 496 SPECTRA_CALC = numpy.uint32(0x00000004)
495 497 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
496 498 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
497 499 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
498 500
499 501 DATATYPE_CHAR = numpy.uint32(0x00000040)
500 502 DATATYPE_SHORT = numpy.uint32(0x00000080)
501 503 DATATYPE_LONG = numpy.uint32(0x00000100)
502 504 DATATYPE_INT64 = numpy.uint32(0x00000200)
503 505 DATATYPE_FLOAT = numpy.uint32(0x00000400)
504 506 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
505 507
506 508 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
507 509 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
508 510 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
509 511
510 512 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
511 513 DEFLIP_DATA = numpy.uint32(0x00010000)
512 514 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
513 515
514 516 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
515 517 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
516 518 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
517 519 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
518 520 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
519 521
520 522 EXP_NAME_ESP = numpy.uint32(0x00200000)
521 523 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
522 524
523 525 OPERATION_MASK = numpy.uint32(0x0000003F)
524 526 DATATYPE_MASK = numpy.uint32(0x00000FC0)
525 527 DATAARRANGE_MASK = numpy.uint32(0x00007000)
526 528 ACQ_SYS_MASK = numpy.uint32(0x001C0000) No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1041 +1,1052
1 1 import numpy
2 2 import time, datetime
3 3 from graphics.figure import *
4 4
5 5 class CrossSpectraPlot(Figure):
6 6
7 7 __isConfig = None
8 8 __nsubplots = None
9 9
10 10 WIDTH = None
11 11 HEIGHT = None
12 12 WIDTHPROF = None
13 13 HEIGHTPROF = None
14 14 PREFIX = 'cspc'
15 15
16 16 def __init__(self):
17 17
18 18 self.__isConfig = False
19 19 self.__nsubplots = 4
20 20
21 21 self.WIDTH = 250
22 22 self.HEIGHT = 250
23 23 self.WIDTHPROF = 0
24 24 self.HEIGHTPROF = 0
25 25
26 26 def getSubplots(self):
27 27
28 28 ncol = 4
29 29 nrow = self.nplots
30 30
31 31 return nrow, ncol
32 32
33 33 def setup(self, idfigure, nplots, wintitle, showprofile=True):
34 34
35 35 self.__showprofile = showprofile
36 36 self.nplots = nplots
37 37
38 38 ncolspan = 1
39 39 colspan = 1
40 40
41 41 self.createFigure(idfigure = idfigure,
42 42 wintitle = wintitle,
43 43 widthplot = self.WIDTH + self.WIDTHPROF,
44 44 heightplot = self.HEIGHT + self.HEIGHTPROF)
45 45
46 46 nrow, ncol = self.getSubplots()
47 47
48 48 counter = 0
49 49 for y in range(nrow):
50 50 for x in range(ncol):
51 51 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
52 52
53 53 counter += 1
54 54
55 55 def run(self, dataOut, idfigure, wintitle="", pairsList=None, showprofile='True',
56 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
56 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, normalize=True,
57 57 save=False, figpath='./', figfile=None,
58 58 power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r'):
59 59
60 60 """
61 61
62 62 Input:
63 63 dataOut :
64 64 idfigure :
65 65 wintitle :
66 66 channelList :
67 67 showProfile :
68 68 xmin : None,
69 69 xmax : None,
70 70 ymin : None,
71 71 ymax : None,
72 72 zmin : None,
73 73 zmax : None
74 74 """
75 75
76 76 if pairsList == None:
77 77 pairsIndexList = dataOut.pairsIndexList
78 78 else:
79 79 pairsIndexList = []
80 80 for pair in pairsList:
81 81 if pair not in dataOut.pairsList:
82 82 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
83 83 pairsIndexList.append(dataOut.pairsList.index(pair))
84 84
85 85 if pairsIndexList == []:
86 86 return
87 87
88 88 if len(pairsIndexList) > 4:
89 89 pairsIndexList = pairsIndexList[0:4]
90
91 factor = 1
92 if normalize:
90 93 factor = dataOut.normFactor
91 94 x = dataOut.getVelRange(1)
92 95 y = dataOut.getHeiRange()
93 96 z = dataOut.data_spc[:,:,:]/factor
94 # z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
97
95 98 avg = numpy.average(z, axis=1)
96 99 noise = dataOut.getNoise()/factor
97 100
98 101 zdB = 10*numpy.log10(z)
99 102 avgdB = 10*numpy.log10(avg)
100 103 noisedB = 10*numpy.log10(noise)
101 104
102 105
103 106 thisDatetime = dataOut.datatime
104 107 title = "Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
105 108 xlabel = "Velocity (m/s)"
106 109 ylabel = "Range (Km)"
107 110
108 111 if not self.__isConfig:
109 112
110 113 nplots = len(pairsIndexList)
111 114
112 115 self.setup(idfigure=idfigure,
113 116 nplots=nplots,
114 117 wintitle=wintitle,
115 118 showprofile=showprofile)
116 119
117 120 if xmin == None: xmin = numpy.nanmin(x)
118 121 if xmax == None: xmax = numpy.nanmax(x)
119 122 if ymin == None: ymin = numpy.nanmin(y)
120 123 if ymax == None: ymax = numpy.nanmax(y)
121 124 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
122 125 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
123 126
124 127 self.__isConfig = True
125 128
126 129 self.setWinTitle(title)
127 130
128 131 for i in range(self.nplots):
129 132 pair = dataOut.pairsList[pairsIndexList[i]]
130 133
131 134 title = "Channel %d: %4.2fdB" %(pair[0], noisedB[pair[0]])
132 135 zdB = 10.*numpy.log10(dataOut.data_spc[pair[0],:,:]/factor)
133 136 axes0 = self.axesList[i*self.__nsubplots]
134 137 axes0.pcolor(x, y, zdB,
135 138 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
136 139 xlabel=xlabel, ylabel=ylabel, title=title,
137 140 ticksize=9, colormap=power_cmap, cblabel='')
138 141
139 142 title = "Channel %d: %4.2fdB" %(pair[1], noisedB[pair[1]])
140 143 zdB = 10.*numpy.log10(dataOut.data_spc[pair[1],:,:]/factor)
141 144 axes0 = self.axesList[i*self.__nsubplots+1]
142 145 axes0.pcolor(x, y, zdB,
143 146 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
144 147 xlabel=xlabel, ylabel=ylabel, title=title,
145 148 ticksize=9, colormap=power_cmap, cblabel='')
146 149
147 150 coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
148 151 coherence = numpy.abs(coherenceComplex)
149 152 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
150 153 phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
151 154
152 155 title = "Coherence %d%d" %(pair[0], pair[1])
153 156 axes0 = self.axesList[i*self.__nsubplots+2]
154 157 axes0.pcolor(x, y, coherence,
155 158 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
156 159 xlabel=xlabel, ylabel=ylabel, title=title,
157 160 ticksize=9, colormap=coherence_cmap, cblabel='')
158 161
159 162 title = "Phase %d%d" %(pair[0], pair[1])
160 163 axes0 = self.axesList[i*self.__nsubplots+3]
161 164 axes0.pcolor(x, y, phase,
162 165 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
163 166 xlabel=xlabel, ylabel=ylabel, title=title,
164 167 ticksize=9, colormap=phase_cmap, cblabel='')
165 168
166 169
167 170
168 171 self.draw()
169 172
170 173 if save:
171 174 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
172 175 if figfile == None:
173 176 figfile = self.getFilename(name = date)
174 177
175 178 self.saveFigure(figpath, figfile)
176 179
177 180
178 181 class RTIPlot(Figure):
179 182
180 183 __isConfig = None
181 184 __nsubplots = None
182 185 __missing = 1E30
183 186 WIDTHPROF = None
184 187 HEIGHTPROF = None
185 188 PREFIX = 'rti'
186 189
187 190 def __init__(self):
188 191
189 192 self.timerange = 2*60*60
190 193 self.__isConfig = False
191 194 self.__nsubplots = 1
192 195
193 196 self.WIDTH = 800
194 197 self.HEIGHT = 200
195 198 self.WIDTHPROF = 120
196 199 self.HEIGHTPROF = 0
197 200 self.x_buffer = None
198 201 self.avgdB_buffer = None
199 202
200 203 def getSubplots(self):
201 204
202 205 ncol = 1
203 206 nrow = self.nplots
204 207
205 208 return nrow, ncol
206 209
207 210 def setup(self, idfigure, nplots, wintitle, showprofile=True):
208 211
209 212 self.__showprofile = showprofile
210 213 self.nplots = nplots
211 214
212 215 ncolspan = 1
213 216 colspan = 1
214 217 if showprofile:
215 218 ncolspan = 7
216 219 colspan = 6
217 220 self.__nsubplots = 2
218 221
219 222 self.createFigure(idfigure = idfigure,
220 223 wintitle = wintitle,
221 224 widthplot = self.WIDTH + self.WIDTHPROF,
222 225 heightplot = self.HEIGHT + self.HEIGHTPROF)
223 226
224 227 nrow, ncol = self.getSubplots()
225 228
226 229 counter = 0
227 230 for y in range(nrow):
228 231 for x in range(ncol):
229 232
230 233 if counter >= self.nplots:
231 234 break
232 235
233 236 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
234 237
235 238 if showprofile:
236 239 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
237 240
238 241 counter += 1
239 242
240 243 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
241 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
244 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, normalize=True,
242 245 timerange=None,
243 246 save=False, figpath='./', figfile=None):
244 247
245 248 """
246 249
247 250 Input:
248 251 dataOut :
249 252 idfigure :
250 253 wintitle :
251 254 channelList :
252 255 showProfile :
253 256 xmin : None,
254 257 xmax : None,
255 258 ymin : None,
256 259 ymax : None,
257 260 zmin : None,
258 261 zmax : None
259 262 """
260 263
261 264 if channelList == None:
262 265 channelIndexList = dataOut.channelIndexList
263 266 else:
264 267 channelIndexList = []
265 268 for channel in channelList:
266 269 if channel not in dataOut.channelList:
267 270 raise ValueError, "Channel %d is not in dataOut.channelList"
268 271 channelIndexList.append(dataOut.channelList.index(channel))
269 272
270 273 if timerange != None:
271 274 self.timerange = timerange
272 275
273 276 tmin = None
274 277 tmax = None
278 factor = 1
279 if normalize:
275 280 factor = dataOut.normFactor
276 281 x = dataOut.getTimeRange()
277 282 y = dataOut.getHeiRange()
278 283
279 284 z = dataOut.data_spc[channelIndexList,:,:]/factor
280 285 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
281 286 avg = numpy.average(z, axis=1)
282 287
283 288 avgdB = 10.*numpy.log10(avg)
284 289
285 290
286 291 thisDatetime = dataOut.datatime
287 292 title = "RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
288 293 xlabel = "Velocity (m/s)"
289 294 ylabel = "Range (Km)"
290 295
291 296 if not self.__isConfig:
292 297
293 298 nplots = len(channelIndexList)
294 299
295 300 self.setup(idfigure=idfigure,
296 301 nplots=nplots,
297 302 wintitle=wintitle,
298 303 showprofile=showprofile)
299 304
300 305 tmin, tmax = self.getTimeLim(x, xmin, xmax)
301 306 if ymin == None: ymin = numpy.nanmin(y)
302 307 if ymax == None: ymax = numpy.nanmax(y)
303 308 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
304 309 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
305 310
306 311 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
307 312 self.x_buffer = numpy.array([])
308 313 self.avgdB_buffer = numpy.array([])
309 314 self.__isConfig = True
310 315
311 316
312 317 self.setWinTitle(title)
313 318
314 319 if len(self.avgdB_buffer)==0:
315 320 self.avgdB_buffer = avgdB
316 321 newxdim = 1
317 322 newydim = -1
318 323 else:
319 324 if x[0]>self.x_buffer[-1]:
320 325 gap = avgdB.copy()
321 326 gap[:] = self.__missing
322 327 self.avgdB_buffer = numpy.hstack((self.avgdB_buffer, gap))
323 328
324 329 self.avgdB_buffer = numpy.hstack((self.avgdB_buffer, avgdB))
325 330 newxdim = -1
326 331 newydim = len(y)
327 332
328 333 self.x_buffer = numpy.hstack((self.x_buffer, x))
329 334
330 335 self.avgdB_buffer = numpy.ma.masked_inside(self.avgdB_buffer,0.99*self.__missing,1.01*self.__missing)
331 336
332 337 for i in range(self.nplots):
333 338 title = "Channel %d: %s" %(dataOut.channelList[i], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
334 339 axes = self.axesList[i*self.__nsubplots]
335 340 zdB = self.avgdB_buffer[i].reshape(newxdim,newydim)
336 341 axes.pcolor(self.x_buffer, y, zdB,
337 342 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
338 343 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
339 344 ticksize=9, cblabel='', cbsize="1%")
340 345
341 346 if self.__showprofile:
342 347 axes = self.axesList[i*self.__nsubplots +1]
343 348 axes.pline(avgdB[i], y,
344 349 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
345 350 xlabel='dB', ylabel='', title='',
346 351 ytick_visible=False,
347 352 grid='x')
348 353
349 354 self.draw()
350 355
351 356 if save:
352 357
353 358 if figfile == None:
354 359 figfile = self.getFilename(name = self.name)
355 360
356 361 self.saveFigure(figpath, figfile)
357 362
358 363 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
359 364 self.__isConfig = False
360 365
361 366 class SpectraPlot(Figure):
362 367
363 368 __isConfig = None
364 369 __nsubplots = None
365 370
366 371 WIDTHPROF = None
367 372 HEIGHTPROF = None
368 373 PREFIX = 'spc'
369 374
370 375 def __init__(self):
371 376
372 377 self.__isConfig = False
373 378 self.__nsubplots = 1
374 379
375 380 self.WIDTH = 230
376 381 self.HEIGHT = 250
377 382 self.WIDTHPROF = 120
378 383 self.HEIGHTPROF = 0
379 384
380 385 def getSubplots(self):
381 386
382 387 ncol = int(numpy.sqrt(self.nplots)+0.9)
383 388 nrow = int(self.nplots*1./ncol + 0.9)
384 389
385 390 return nrow, ncol
386 391
387 392 def setup(self, idfigure, nplots, wintitle, showprofile=True):
388 393
389 394 self.__showprofile = showprofile
390 395 self.nplots = nplots
391 396
392 397 ncolspan = 1
393 398 colspan = 1
394 399 if showprofile:
395 400 ncolspan = 3
396 401 colspan = 2
397 402 self.__nsubplots = 2
398 403
399 404 self.createFigure(idfigure = idfigure,
400 405 wintitle = wintitle,
401 406 widthplot = self.WIDTH + self.WIDTHPROF,
402 407 heightplot = self.HEIGHT + self.HEIGHTPROF)
403 408
404 409 nrow, ncol = self.getSubplots()
405 410
406 411 counter = 0
407 412 for y in range(nrow):
408 413 for x in range(ncol):
409 414
410 415 if counter >= self.nplots:
411 416 break
412 417
413 418 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
414 419
415 420 if showprofile:
416 421 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
417 422
418 423 counter += 1
419 424
420 425 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
421 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
426 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, normalize=True,
422 427 save=False, figpath='./', figfile=None):
423 428
424 429 """
425 430
426 431 Input:
427 432 dataOut :
428 433 idfigure :
429 434 wintitle :
430 435 channelList :
431 436 showProfile :
432 437 xmin : None,
433 438 xmax : None,
434 439 ymin : None,
435 440 ymax : None,
436 441 zmin : None,
437 442 zmax : None
438 443 """
439 444
440 445 if channelList == None:
441 446 channelIndexList = dataOut.channelIndexList
442 447 else:
443 448 channelIndexList = []
444 449 for channel in channelList:
445 450 if channel not in dataOut.channelList:
446 451 raise ValueError, "Channel %d is not in dataOut.channelList"
447 452 channelIndexList.append(dataOut.channelList.index(channel))
453 factor = 1
454 if normalize:
448 455 factor = dataOut.normFactor
449 456 x = dataOut.getVelRange(1)
450 457 y = dataOut.getHeiRange()
451 458
452 459 z = dataOut.data_spc[channelIndexList,:,:]/factor
453 460 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
454 461 avg = numpy.average(z, axis=1)
455 462 noise = dataOut.getNoise()/factor
456 463
457 464 zdB = 10*numpy.log10(z)
458 465 avgdB = 10*numpy.log10(avg)
459 466 noisedB = 10*numpy.log10(noise)
460 467
461 468 thisDatetime = dataOut.datatime
462 469 title = "Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
463 470 xlabel = "Velocity (m/s)"
464 471 ylabel = "Range (Km)"
465 472
466 473 if not self.__isConfig:
467 474
468 475 nplots = len(channelIndexList)
469 476
470 477 self.setup(idfigure=idfigure,
471 478 nplots=nplots,
472 479 wintitle=wintitle,
473 480 showprofile=showprofile)
474 481
475 482 if xmin == None: xmin = numpy.nanmin(x)
476 483 if xmax == None: xmax = numpy.nanmax(x)
477 484 if ymin == None: ymin = numpy.nanmin(y)
478 485 if ymax == None: ymax = numpy.nanmax(y)
479 486 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
480 487 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
481 488
482 489 self.__isConfig = True
483 490
484 491 self.setWinTitle(title)
485 492
486 493 for i in range(self.nplots):
487 494 title = "Channel %d: %4.2fdB" %(dataOut.channelList[i], noisedB[i])
488 495 axes = self.axesList[i*self.__nsubplots]
489 496 axes.pcolor(x, y, zdB[i,:,:],
490 497 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
491 498 xlabel=xlabel, ylabel=ylabel, title=title,
492 499 ticksize=9, cblabel='')
493 500
494 501 if self.__showprofile:
495 502 axes = self.axesList[i*self.__nsubplots +1]
496 503 axes.pline(avgdB[i], y,
497 504 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
498 505 xlabel='dB', ylabel='', title='',
499 506 ytick_visible=False,
500 507 grid='x')
501 508
502 509 noiseline = numpy.repeat(noisedB[i], len(y))
503 510 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
504 511
505 512 self.draw()
506 513
507 514 if save:
508 515 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
509 516 if figfile == None:
510 517 figfile = self.getFilename(name = date)
511 518
512 519 self.saveFigure(figpath, figfile)
513 520
514 521 class Scope(Figure):
515 522
516 523 __isConfig = None
517 524
518 525 def __init__(self):
519 526
520 527 self.__isConfig = False
521 528 self.WIDTH = 600
522 529 self.HEIGHT = 200
523 530
524 531 def getSubplots(self):
525 532
526 533 nrow = self.nplots
527 534 ncol = 3
528 535 return nrow, ncol
529 536
530 537 def setup(self, idfigure, nplots, wintitle):
531 538
532 539 self.nplots = nplots
533 540
534 541 self.createFigure(idfigure, wintitle)
535 542
536 543 nrow,ncol = self.getSubplots()
537 544 colspan = 3
538 545 rowspan = 1
539 546
540 547 for i in range(nplots):
541 548 self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
542 549
543 550
544 551
545 552 def run(self, dataOut, idfigure, wintitle="", channelList=None,
546 553 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
547 554 figpath='./', figfile=None):
548 555
549 556 """
550 557
551 558 Input:
552 559 dataOut :
553 560 idfigure :
554 561 wintitle :
555 562 channelList :
556 563 xmin : None,
557 564 xmax : None,
558 565 ymin : None,
559 566 ymax : None,
560 567 """
561 568
562 569 if channelList == None:
563 570 channelIndexList = dataOut.channelIndexList
564 571 else:
565 572 channelIndexList = []
566 573 for channel in channelList:
567 574 if channel not in dataOut.channelList:
568 575 raise ValueError, "Channel %d is not in dataOut.channelList"
569 576 channelIndexList.append(dataOut.channelList.index(channel))
570 577
571 578 x = dataOut.heightList
572 579 y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
573 580 y = y.real
574 581
575 582 thisDatetime = dataOut.datatime
576 583 title = "Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
577 584 xlabel = "Range (Km)"
578 585 ylabel = "Intensity"
579 586
580 587 if not self.__isConfig:
581 588 nplots = len(channelIndexList)
582 589
583 590 self.setup(idfigure=idfigure,
584 591 nplots=nplots,
585 592 wintitle=wintitle)
586 593
587 594 if xmin == None: xmin = numpy.nanmin(x)
588 595 if xmax == None: xmax = numpy.nanmax(x)
589 596 if ymin == None: ymin = numpy.nanmin(y)
590 597 if ymax == None: ymax = numpy.nanmax(y)
591 598
592 599 self.__isConfig = True
593 600
594 601 self.setWinTitle(title)
595 602
596 603 for i in range(len(self.axesList)):
597 604 title = "Channel %d" %(i)
598 605 axes = self.axesList[i]
599 606 ychannel = y[i,:]
600 607 axes.pline(x, ychannel,
601 608 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
602 609 xlabel=xlabel, ylabel=ylabel, title=title)
603 610
604 611 self.draw()
605 612
606 613 if save:
607 614 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
608 615 if figfile == None:
609 616 figfile = self.getFilename(name = date)
610 617
611 618 self.saveFigure(figpath, figfile)
612 619
613 620 class ProfilePlot(Figure):
614 621 __isConfig = None
615 622 __nsubplots = None
616 623
617 624 WIDTHPROF = None
618 625 HEIGHTPROF = None
619 626 PREFIX = 'spcprofile'
620 627
621 628 def __init__(self):
622 629 self.__isConfig = False
623 630 self.__nsubplots = 1
624 631
625 632 self.WIDTH = 300
626 633 self.HEIGHT = 500
627 634
628 635 def getSubplots(self):
629 636 ncol = 1
630 637 nrow = 1
631 638
632 639 return nrow, ncol
633 640
634 641 def setup(self, idfigure, nplots, wintitle):
635 642
636 643 self.nplots = nplots
637 644
638 645 ncolspan = 1
639 646 colspan = 1
640 647
641 648 self.createFigure(idfigure = idfigure,
642 649 wintitle = wintitle,
643 650 widthplot = self.WIDTH,
644 651 heightplot = self.HEIGHT)
645 652
646 653 nrow, ncol = self.getSubplots()
647 654
648 655 counter = 0
649 656 for y in range(nrow):
650 657 for x in range(ncol):
651 658 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
652 659
653 660 def run(self, dataOut, idfigure, wintitle="", channelList=None,
654 xmin=None, xmax=None, ymin=None, ymax=None,
661 xmin=None, xmax=None, ymin=None, ymax=None, normalize=True,
655 662 save=False, figpath='./', figfile=None):
656 663
657 664 if channelList == None:
658 665 channelIndexList = dataOut.channelIndexList
659 666 channelList = dataOut.channelList
660 667 else:
661 668 channelIndexList = []
662 669 for channel in channelList:
663 670 if channel not in dataOut.channelList:
664 671 raise ValueError, "Channel %d is not in dataOut.channelList"
665 672 channelIndexList.append(dataOut.channelList.index(channel))
666 673
674 factor = 1
675 if normalize:
667 676 factor = dataOut.normFactor
668 677 y = dataOut.getHeiRange()
669 678 x = dataOut.data_spc[channelIndexList,:,:]/factor
670 679 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
671 680 avg = numpy.average(x, axis=1)
672 681
673 682 avgdB = 10*numpy.log10(avg)
674 683
675 684 thisDatetime = dataOut.datatime
676 685 title = "Power Profile"
677 686 xlabel = "dB"
678 687 ylabel = "Range (Km)"
679 688
680 689 if not self.__isConfig:
681 690
682 691 nplots = 1
683 692
684 693 self.setup(idfigure=idfigure,
685 694 nplots=nplots,
686 695 wintitle=wintitle)
687 696
688 697 if ymin == None: ymin = numpy.nanmin(y)
689 698 if ymax == None: ymax = numpy.nanmax(y)
690 699 if xmin == None: xmin = numpy.nanmin(avgdB)*0.9
691 700 if xmax == None: xmax = numpy.nanmax(avgdB)*0.9
692 701
693 702 self.__isConfig = True
694 703
695 704 self.setWinTitle(title)
696 705
697 706
698 707 title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
699 708 axes = self.axesList[0]
700 709
701 710 legendlabels = ["channel %d"%x for x in channelList]
702 711 axes.pmultiline(avgdB, y,
703 712 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
704 713 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
705 714 ytick_visible=True, nxticks=5,
706 715 grid='x')
707 716
708 717 self.draw()
709 718
710 719 if save:
711 720 date = thisDatetime.strftime("%Y%m%d")
712 721 if figfile == None:
713 722 figfile = self.getFilename(name = date)
714 723
715 724 self.saveFigure(figpath, figfile)
716 725
717 726 class CoherenceMap(Figure):
718 727 __isConfig = None
719 728 __nsubplots = None
720 729
721 730 WIDTHPROF = None
722 731 HEIGHTPROF = None
723 732 PREFIX = 'cmap'
724 733 __missing = 1E30
725 734
726 735 def __init__(self):
727 736 self.timerange = 2*60*60
728 737 self.__isConfig = False
729 738 self.__nsubplots = 1
730 739
731 740 self.WIDTH = 800
732 741 self.HEIGHT = 200
733 742 self.WIDTHPROF = 120
734 743 self.HEIGHTPROF = 0
735 744 self.x_buffer = None
736 745 self.coherence_buffer = None
737 746 self.phase_buffer = None
738 747
739 748 def getSubplots(self):
740 749 ncol = 1
741 750 nrow = self.nplots*2
742 751
743 752 return nrow, ncol
744 753
745 754 def setup(self, idfigure, nplots, wintitle, showprofile=True):
746 755 self.__showprofile = showprofile
747 756 self.nplots = nplots
748 757
749 758 ncolspan = 1
750 759 colspan = 1
751 760 if showprofile:
752 761 ncolspan = 7
753 762 colspan = 6
754 763 self.__nsubplots = 2
755 764
756 765 self.createFigure(idfigure = idfigure,
757 766 wintitle = wintitle,
758 767 widthplot = self.WIDTH + self.WIDTHPROF,
759 768 heightplot = self.HEIGHT + self.HEIGHTPROF)
760 769
761 770 nrow, ncol = self.getSubplots()
762 771
763 772 for y in range(nrow):
764 773 for x in range(ncol):
765 774
766 775 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
767 776
768 777 if showprofile:
769 778 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
770 779
771 780 def run(self, dataOut, idfigure, wintitle="", pairsList=None, showprofile='True',
772 781 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
773 782 timerange=None,
774 783 save=False, figpath='./', figfile=None,
775 784 coherence_cmap='jet', phase_cmap='RdBu_r'):
776 785
777 786 if pairsList == None:
778 787 pairsIndexList = dataOut.pairsIndexList
779 788 else:
780 789 pairsIndexList = []
781 790 for pair in pairsList:
782 791 if pair not in dataOut.pairsList:
783 792 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
784 793 pairsIndexList.append(dataOut.pairsList.index(pair))
785 794
786 795 if timerange != None:
787 796 self.timerange = timerange
788 797
789 798 if pairsIndexList == []:
790 799 return
791 800
792 801 if len(pairsIndexList) > 4:
793 802 pairsIndexList = pairsIndexList[0:4]
794 803
795 804 tmin = None
796 805 tmax = None
797 806 x = dataOut.getTimeRange()
798 807 y = dataOut.getHeiRange()
799 808
800 809 thisDatetime = dataOut.datatime
801 810 title = "CoherenceMap: %s" %(thisDatetime.strftime("%d-%b-%Y"))
802 811 xlabel = ""
803 812 ylabel = "Range (Km)"
804 813
805 814 if not self.__isConfig:
806 815 nplots = len(pairsIndexList)
807 816 self.setup(idfigure=idfigure,
808 817 nplots=nplots,
809 818 wintitle=wintitle,
810 819 showprofile=showprofile)
811 820
812 821 tmin, tmax = self.getTimeLim(x, xmin, xmax)
813 822 if ymin == None: ymin = numpy.nanmin(y)
814 823 if ymax == None: ymax = numpy.nanmax(y)
815 824
816 825 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
817 826 self.x_buffer = numpy.array([])
818 827 self.coherence_buffer = numpy.array([])
819 828 self.phase_buffer = numpy.array([])
820 829 self.__isConfig = True
821 830
822 831 self.setWinTitle(title)
823 832
824 833
825 834 pairArray = numpy.array(dataOut.pairsList)
826 835 pairArray = pairArray[pairsIndexList]
827 836 pair0ids = pairArray[:,0]
828 837 pair1ids = pairArray[:,1]
829 838
830 839 coherenceComplex = dataOut.data_cspc[pairsIndexList,:,:]/numpy.sqrt(dataOut.data_spc[pair0ids,:,:]*dataOut.data_spc[pair1ids,:,:])
831 840 avgcoherenceComplex = numpy.average(coherenceComplex, axis=1)
832 841 coherence = numpy.abs(avgcoherenceComplex)
833 842
834 843 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
835 844
836 845 if len(self.coherence_buffer)==0:
837 846 self.coherence_buffer = coherence
838 847 self.phase_buffer = phase
839 848 newxdim = 1
840 849 newydim = -1
841 850 else:
842 851 if x[0]>self.x_buffer[-1]:
843 852 gap = coherence.copy()
844 853 gap[:] = self.__missing
845 854 self.coherence_buffer = numpy.hstack((self.coherence_buffer, gap))
846 855 self.phase_buffer = numpy.hstack((self.phase_buffer, gap))
847 856
848 857 self.coherence_buffer = numpy.hstack((self.coherence_buffer, coherence))
849 858 self.phase_buffer = numpy.hstack((self.phase_buffer, phase))
850 859 newxdim = -1
851 860 newydim = len(y)
852 861
853 862 self.x_buffer = numpy.hstack((self.x_buffer, x))
854 863
855 864 self.coherence_buffer = numpy.ma.masked_inside(self.coherence_buffer,0.99*self.__missing,1.01*self.__missing)
856 865 self.phase_buffer = numpy.ma.masked_inside(self.phase_buffer,0.99*self.__missing,1.01*self.__missing)
857 866
858 867
859 868 for i in range(self.nplots):
860 869 counter = 0
861 870 z = self.coherence_buffer[i,:].reshape((newxdim,newydim))
862 871 title = "Coherence %d%d: %s" %(pair0ids[i], pair1ids[i], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
863 872 axes = self.axesList[i*self.__nsubplots*2]
864 873 axes.pcolor(self.x_buffer, y, z,
865 874 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
866 875 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
867 876 ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
868 877
869 878 if self.__showprofile:
870 879 counter += 1
871 880 axes = self.axesList[i*self.__nsubplots*2 + counter]
872 881 axes.pline(coherence[i,:], y,
873 882 xmin=0, xmax=1, ymin=ymin, ymax=ymax,
874 883 xlabel='', ylabel='', title='', ticksize=7,
875 884 ytick_visible=False, nxticks=5,
876 885 grid='x')
877 886
878 887 counter += 1
879 888
880 889 z = self.phase_buffer[i,:].reshape((newxdim,newydim))
881 890
882 891 title = "Phase %d%d: %s" %(pair0ids[i], pair1ids[i], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
883 892 axes = self.axesList[i*self.__nsubplots*2 + counter]
884 893 axes.pcolor(self.x_buffer, y, z,
885 894 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
886 895 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
887 896 ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
888 897
889 898 if self.__showprofile:
890 899 counter += 1
891 900 axes = self.axesList[i*self.__nsubplots*2 + counter]
892 901 axes.pline(phase[i,:], y,
893 902 xmin=-180, xmax=180, ymin=ymin, ymax=ymax,
894 903 xlabel='', ylabel='', title='', ticksize=7,
895 904 ytick_visible=False, nxticks=4,
896 905 grid='x')
897 906
898 907 self.draw()
899 908
900 909 if save:
901 910
902 911 if figfile == None:
903 912 figfile = self.getFilename(name = self.name)
904 913
905 914 self.saveFigure(figpath, figfile)
906 915
907 916 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
908 917 self.__isConfig = False
909 918
910 919 class RTIfromNoise(Figure):
911 920
912 921 __isConfig = None
913 922 __nsubplots = None
914 923
915 924 PREFIX = 'rtinoise'
916 925
917 926 def __init__(self):
918 927
919 928 self.timerange = 24*60*60
920 929 self.__isConfig = False
921 930 self.__nsubplots = 1
922 931
923 932 self.WIDTH = 820
924 933 self.HEIGHT = 200
925 934 self.WIDTHPROF = 120
926 935 self.HEIGHTPROF = 0
927 936 self.xdata = None
928 937 self.ydata = None
929 938
930 939 def getSubplots(self):
931 940
932 941 ncol = 1
933 942 nrow = 1
934 943
935 944 return nrow, ncol
936 945
937 946 def setup(self, idfigure, nplots, wintitle, showprofile=True):
938 947
939 948 self.__showprofile = showprofile
940 949 self.nplots = nplots
941 950
942 951 ncolspan = 7
943 952 colspan = 6
944 953 self.__nsubplots = 2
945 954
946 955 self.createFigure(idfigure = idfigure,
947 956 wintitle = wintitle,
948 957 widthplot = self.WIDTH+self.WIDTHPROF,
949 958 heightplot = self.HEIGHT+self.HEIGHTPROF)
950 959
951 960 nrow, ncol = self.getSubplots()
952 961
953 962 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
954 963
955 964
956 965 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
957 xmin=None, xmax=None, ymin=None, ymax=None,
966 xmin=None, xmax=None, ymin=None, ymax=None, normalize=True,
958 967 timerange=None,
959 968 save=False, figpath='./', figfile=None):
960 969
961 970 if channelList == None:
962 971 channelIndexList = dataOut.channelIndexList
963 972 channelList = dataOut.channelList
964 973 else:
965 974 channelIndexList = []
966 975 for channel in channelList:
967 976 if channel not in dataOut.channelList:
968 977 raise ValueError, "Channel %d is not in dataOut.channelList"
969 978 channelIndexList.append(dataOut.channelList.index(channel))
970 979
971 980 if timerange != None:
972 981 self.timerange = timerange
973 982
974 983 tmin = None
975 984 tmax = None
976 985 x = dataOut.getTimeRange()
977 986 y = dataOut.getHeiRange()
987 factor = 1
988 if normalize:
978 989 factor = dataOut.normFactor
979 990 noise = dataOut.getNoise()/factor
980 991 noisedB = 10*numpy.log10(noise)
981 992
982 993 thisDatetime = dataOut.datatime
983 994 title = "RTI Noise: %s" %(thisDatetime.strftime("%d-%b-%Y"))
984 995 xlabel = ""
985 996 ylabel = "Range (Km)"
986 997
987 998 if not self.__isConfig:
988 999
989 1000 nplots = 1
990 1001
991 1002 self.setup(idfigure=idfigure,
992 1003 nplots=nplots,
993 1004 wintitle=wintitle,
994 1005 showprofile=showprofile)
995 1006
996 1007 tmin, tmax = self.getTimeLim(x, xmin, xmax)
997 1008 if ymin == None: ymin = numpy.nanmin(noisedB)
998 1009 if ymax == None: ymax = numpy.nanmax(noisedB)
999 1010
1000 1011 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1001 1012 self.__isConfig = True
1002 1013
1003 1014 self.xdata = numpy.array([])
1004 1015 self.ydata = numpy.array([])
1005 1016
1006 1017 self.setWinTitle(title)
1007 1018
1008 1019
1009 1020 title = "RTI Noise %s" %(thisDatetime.strftime("%d-%b-%Y"))
1010 1021
1011 1022 legendlabels = ["channel %d"%idchannel for idchannel in channelList]
1012 1023 axes = self.axesList[0]
1013 1024
1014 1025 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1015 1026
1016 1027 if len(self.ydata)==0:
1017 1028 self.ydata = noisedB[channelIndexList].reshape(-1,1)
1018 1029 else:
1019 1030 self.ydata = numpy.hstack((self.ydata, noisedB[channelIndexList].reshape(-1,1)))
1020 1031
1021 1032
1022 1033 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1023 1034 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
1024 1035 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1025 1036 XAxisAsTime=True
1026 1037 )
1027 1038
1028 1039 self.draw()
1029 1040
1030 1041 if save:
1031 1042
1032 1043 if figfile == None:
1033 1044 figfile = self.getFilename(name = self.name)
1034 1045
1035 1046 self.saveFigure(figpath, figfile)
1036 1047
1037 1048 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
1038 1049 self.__isConfig = False
1039 1050 del self.xdata
1040 1051 del self.ydata
1041 1052 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now