##// END OF EJS Templates
schain
RSS
AMISR modules to read hdf5 files and link to SignalChain Objects...
Daniel Valdez -
r491:3acb3a6f21eb
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,59
1 import numpy
2
3 class AMISR:
4 def __init__(self):
5 self.flagNoData = True
6 self.data = None
7 self.utctime = None
8 self.type = "AMISR"
9
10 #propiedades para compatibilidad con Voltages
11 self.timeZone = 300#timezone like jroheader, difference in minutes between UTC and localtime
12 self.dstFlag = 0#self.dataIn.dstFlag
13 self.errorCount = 0#self.dataIn.errorCount
14 self.useLocalTime = True#self.dataIn.useLocalTime
15
16 self.radarControllerHeaderObj = None#self.dataIn.radarControllerHeaderObj.copy()
17 self.systemHeaderObj = None#self.dataIn.systemHeaderObj.copy()
18 self.channelList = [0]#self.dataIn.channelList esto solo aplica para el caso de AMISR
19 self.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
20
21 self.flagTimeBlock = None#self.dataIn.flagTimeBlock
22 #self.utctime = #self.firstdatatime
23 self.flagDecodeData = None#self.dataIn.flagDecodeData #asumo q la data esta decodificada
24 self.flagDeflipData = None#self.dataIn.flagDeflipData #asumo q la data esta sin flip
25
26 self.nCohInt = 1#self.dataIn.nCohInt
27 self.nIncohInt = 1
28 self.ippSeconds = None#self.dataIn.ippSeconds, segun el filename/Setup/Tufile
29 self.windowOfFilter = None#self.dataIn.windowOfFilter
30
31 self.timeInterval = None#self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
32 self.frequency = None#self.dataIn.frequency
33 self.realtime = 0#self.dataIn.realtime
34
35 #actualizar en la lectura de datos
36 self.heightList = None#self.dataIn.heightList
37 self.nProfiles = None#Number of samples or nFFTPoints
38 self.nRecords = None
39 self.nBeams = None
40 self.nBaud = None#self.dataIn.nBaud
41 self.nCode = None#self.dataIn.nCode
42 self.code = None#self.dataIn.code
43
44 #consideracion para los Beams
45 self.beamCodeDict = None
46 self.beamRangeDict = None
47
48 def copy(self, inputObj=None):
49
50 if inputObj == None:
51 return copy.deepcopy(self)
52
53 for key in inputObj.__dict__.keys():
54 self.__dict__[key] = inputObj.__dict__[key]
55
56
57 def isEmpty(self):
58
59 return self.flagNoData No newline at end of file
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (542 lines changed) Show them Hide them
@@ -0,0 +1,542
1 '''
2 @author: Daniel Suarez
3 '''
4
5 import os
6 import sys
7 import glob
8 import fnmatch
9 import datetime
10 import re
11 import h5py
12 import numpy
13
14 from model.proc.jroproc_base import ProcessingUnit, Operation
15 from model.data.jroamisr import AMISR
16
17 class RadacHeader():
18 def __init__(self, fp):
19 header = 'Raw11/Data/RadacHeader'
20 self.beamCodeByPulse = fp.get(header+'/BeamCode')
21 self.beamCode = fp.get('Raw11/Data/Beamcodes')
22 self.code = fp.get(header+'/Code')
23 self.frameCount = fp.get(header+'/FrameCount')
24 self.modeGroup = fp.get(header+'/ModeGroup')
25 self.nsamplesPulse = fp.get(header+'/NSamplesPulse')
26 self.pulseCount = fp.get(header+'/PulseCount')
27 self.radacTime = fp.get(header+'/RadacTime')
28 self.timeCount = fp.get(header+'/TimeCount')
29 self.timeStatus = fp.get(header+'/TimeStatus')
30
31 self.nrecords = self.pulseCount.shape[0] #nblocks
32 self.npulses = self.pulseCount.shape[1] #nprofile
33 self.nsamples = self.nsamplesPulse[0,0] #ngates
34 self.nbeams = self.beamCode.shape[1]
35
36
37 def getIndexRangeToPulse(self, idrecord=0):
38 indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)
39 startPulseCountId = indexToZero[0][0]
40 endPulseCountId = startPulseCountId - 1
41 range1 = numpy.arange(startPulseCountId,self.npulses,1)
42 range2 = numpy.arange(0,startPulseCountId,1)
43 return range1, range2
44
45
46 class AMISRReader(ProcessingUnit):
47
48 path = None
49 startDate = None
50 endDate = None
51 startTime = None
52 endTime = None
53 walk = None
54 isConfig = False
55
56 def __init__(self):
57 self.set = None
58 self.subset = None
59 self.extension_file = '.h5'
60 self.dtc_str = 'dtc'
61 self.dtc_id = 0
62 self.status = True
63 self.isConfig = False
64 self.dirnameList = []
65 self.filenameList = []
66 self.fileIndex = None
67 self.flagNoMoreFiles = False
68 self.flagIsNewFile = 0
69 self.filename = ''
70 self.amisrFilePointer = None
71 self.radacHeaderObj = None
72 self.dataOut = self.__createObjByDefault()
73 self.datablock = None
74 self.rest_datablock = None
75 self.range = None
76 self.idrecord_count = 0
77 self.profileIndex = 0
78 self.idpulse_range1 = None
79 self.idpulse_range2 = None
80 self.beamCodeByFrame = None
81 self.radacTimeByFrame = None
82 #atributos originales tal y como esta en el archivo de datos
83 self.beamCodesFromFile = None
84 self.radacTimeFromFile = None
85 self.rangeFromFile = None
86 self.dataByFrame = None
87 self.dataset = None
88
89 self.beamCodeDict = {}
90 self.beamRangeDict = {}
91
92 #experiment cgf file
93 self.npulsesint_fromfile = None
94 self.recordsperfile_fromfile = None
95 self.nbeamcodes_fromfile = None
96 self.ngates_fromfile = None
97 self.ippSeconds_fromfile = None
98 self.frequency_h5file = None
99
100
101 self.__firstFile = True
102 self.buffer_radactime = None
103
104 def __createObjByDefault(self):
105
106 dataObj = AMISR()
107
108 return dataObj
109
110 def __setParameters(self,path,startDate,endDate,startTime,endTime,walk):
111 self.path = path
112 self.startDate = startDate
113 self.endDate = endDate
114 self.startTime = startTime
115 self.endTime = endTime
116 self.walk = walk
117
118 def __checkPath(self):
119 if os.path.exists(self.path):
120 self.status = 1
121 else:
122 self.status = 0
123 print 'Path:%s does not exists'%self.path
124
125 return
126
127 def __selDates(self, amisr_dirname_format):
128 try:
129 year = int(amisr_dirname_format[0:4])
130 month = int(amisr_dirname_format[4:6])
131 dom = int(amisr_dirname_format[6:8])
132 thisDate = datetime.date(year,month,dom)
133
134 if (thisDate>=self.startDate and thisDate <= self.endDate):
135 return amisr_dirname_format
136 except:
137 return None
138
139 def __findDataForDates(self):
140
141
142
143 if not(self.status):
144 return None
145
146 pat = '\d+.\d+'
147 dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
148 dirnameList = filter(lambda x:x!=None,dirnameList)
149 dirnameList = [x.string for x in dirnameList]
150 dirnameList = [self.__selDates(x) for x in dirnameList]
151 dirnameList = filter(lambda x:x!=None,dirnameList)
152 if len(dirnameList)>0:
153 self.status = 1
154 self.dirnameList = dirnameList
155 self.dirnameList.sort()
156 else:
157 self.status = 0
158 return None
159
160 def __getTimeFromData(self):
161 pass
162
163 def __filterByGlob1(self, dirName):
164 filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)
165 filterDict = {}
166 filterDict.setdefault(dirName)
167 filterDict[dirName] = filter_files
168 return filterDict
169
170 def __getFilenameList(self, fileListInKeys, dirList):
171 for value in fileListInKeys:
172 dirName = value.keys()[0]
173 for file in value[dirName]:
174 filename = os.path.join(dirName, file)
175 self.filenameList.append(filename)
176
177
178 def __selectDataForTimes(self):
179 #aun no esta implementado el filtro for tiempo
180 if not(self.status):
181 return None
182
183 dirList = [os.path.join(self.path,x) for x in self.dirnameList]
184
185 fileListInKeys = [self.__filterByGlob1(x) for x in dirList]
186
187 self.__getFilenameList(fileListInKeys, dirList)
188
189 if len(self.filenameList)>0:
190 self.status = 1
191 self.filenameList.sort()
192 else:
193 self.status = 0
194 return None
195
196
197 def __searchFilesOffline(self,
198 path,
199 startDate,
200 endDate,
201 startTime=datetime.time(0,0,0),
202 endTime=datetime.time(23,59,59),
203 walk=True):
204
205 self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
206
207 self.__checkPath()
208
209 self.__findDataForDates()
210
211 self.__selectDataForTimes()
212
213 for i in range(len(self.filenameList)):
214 print "%s" %(self.filenameList[i])
215
216 return
217
218 def __setNextFileOffline(self):
219 idFile = self.fileIndex
220
221 while (True):
222 idFile += 1
223 if not(idFile < len(self.filenameList)):
224 self.flagNoMoreFiles = 1
225 print "No more Files"
226 return 0
227
228 filename = self.filenameList[idFile]
229
230 amisrFilePointer = h5py.File(filename,'r')
231
232 break
233
234 self.flagIsNewFile = 1
235 self.fileIndex = idFile
236 self.filename = filename
237
238 self.amisrFilePointer = amisrFilePointer
239
240 print "Setting the file: %s"%self.filename
241
242 return 1
243
244 def __readHeader(self):
245 self.radacHeaderObj = RadacHeader(self.amisrFilePointer)
246
247 #update values from experiment cfg file
248 if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile:
249 self.radacHeaderObj.nrecords = self.recordsperfile_fromfile
250 self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile
251 self.radacHeaderObj.npulses = self.npulsesint_fromfile
252 self.radacHeaderObj.nsamples = self.ngates_fromfile
253
254 #get tuning frequency
255 frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency')
256 self.frequency_h5file = frequency_h5file_dataset[0,0]
257
258 self.flagIsNewFile = 1
259
260 def __getBeamCode(self):
261 self.beamCodeDict = {}
262 self.beamRangeDict = {}
263
264 for i in range(len(self.radacHeaderObj.beamCode[0,:])):
265 self.beamCodeDict.setdefault(i)
266 self.beamRangeDict.setdefault(i)
267 self.beamCodeDict[i] = self.radacHeaderObj.beamCode[0,i]
268
269
270 just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:]
271
272 for i in range(len(self.beamCodeDict.values())):
273 xx = numpy.where(just4record0==self.beamCodeDict.values()[i])
274 self.beamRangeDict[i] = xx[0]
275
276 def __getExpParameters(self):
277 if not(self.status):
278 return None
279
280 experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup')
281
282 expFinder = glob.glob1(experimentCfgPath,'*.exp')
283 if len(expFinder)== 0:
284 self.status = 0
285 return None
286
287 experimentFilename = os.path.join(experimentCfgPath,expFinder[0])
288
289 f = open(experimentFilename)
290 lines = f.readlines()
291 f.close()
292
293 parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*']
294 filterList = [fnmatch.filter(lines, x) for x in parmsList]
295
296
297 values = [re.sub(r'\D',"",x[0]) for x in filterList]
298
299 self.npulsesint_fromfile = int(values[0])
300 self.recordsperfile_fromfile = int(values[1])
301 self.nbeamcodes_fromfile = int(values[2])
302 self.ngates_fromfile = int(values[3])
303
304 tufileFinder = fnmatch.filter(lines, 'tufile=*')
305 tufile = tufileFinder[0].split('=')[1].split('\n')[0]
306 tufilename = os.path.join(experimentCfgPath,tufile)
307
308 f = open(tufilename)
309 lines = f.readlines()
310 f.close()
311 self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6
312
313
314 self.status = 1
315
316 def __setIdsAndArrays(self):
317 self.dataByFrame = self.__setDataByFrame()
318 self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[0, :]
319 self.readRanges()
320 self.idpulse_range1, self.idpulse_range2 = self.radacHeaderObj.getIndexRangeToPulse(0)
321 self.radacTimeByFrame = numpy.zeros(self.radacHeaderObj.npulses)
322 self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame)
323
324
325 def __setNextFile(self):
326
327 newFile = self.__setNextFileOffline()
328
329 if not(newFile):
330 return 0
331
332 self.__readHeader()
333
334 if self.__firstFile:
335 self.__setIdsAndArrays()
336 self.__firstFile = False
337
338 self.__getBeamCode()
339 self.readDataBlock()
340
341
342 def setup(self,path=None,
343 startDate=None,
344 endDate=None,
345 startTime=datetime.time(0,0,0),
346 endTime=datetime.time(23,59,59),
347 walk=True):
348
349 #Busqueda de archivos offline
350 self.__searchFilesOffline(path, startDate, endDate, startTime, endTime, walk)
351
352 if not(self.filenameList):
353 print "There is no files into the folder: %s"%(path)
354
355 sys.exit(-1)
356
357 self.__getExpParameters()
358
359 self.fileIndex = -1
360
361 self.__setNextFile()
362
363 def readRanges(self):
364 dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range')
365 #self.rangeFromFile = dataset.value
366 self.rangeFromFile = numpy.reshape(dataset.value,(-1))
367 return range
368
369
370 def readRadacTime(self,idrecord, range1, range2):
371 self.radacTimeFromFile = self.radacHeaderObj.radacTime.value
372
373 radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
374 #radacTimeByFrame = dataset[idrecord - 1,range1]
375 #radacTimeByFrame = dataset[idrecord,range2]
376
377 return radacTimeByFrame
378
379 def readBeamCode(self, idrecord, range1, range2):
380 dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode')
381 beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
382 self.beamCodesFromFile = dataset.value
383
384 #beamcodeByFrame[range1] = dataset[idrecord - 1, range1]
385 #beamcodeByFrame[range2] = dataset[idrecord, range2]
386 beamcodeByFrame[range1] = dataset[idrecord, range1]
387 beamcodeByFrame[range2] = dataset[idrecord, range2]
388
389 return beamcodeByFrame
390
391
392 def __setDataByFrame(self):
393 ndata = 2 # porque es complejo
394 dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata))
395 return dataByFrame
396
397 def __readDataSet(self):
398 dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data')
399 return dataset
400
401 def __setDataBlock(self,):
402 real = self.dataByFrame[:,:,0] #asumo que 0 es real
403 imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario
404 datablock = real + imag*1j #armo el complejo
405 return datablock
406
407 def readSamples_version1(self,idrecord):
408 #estas tres primeras lineas solo se deben ejecutar una vez
409 if self.flagIsNewFile:
410 #reading dataset
411 self.dataset = self.__readDataSet()
412 self.flagIsNewFile = 0
413
414 if idrecord == 0:
415 #if self.buffer_last_record == None:
416 selectorById = self.radacHeaderObj.pulseCount[0,self.idpulse_range2]
417
418 self.dataByFrame[selectorById,:,:] = self.dataset[0, self.idpulse_range2,:,:]
419
420 self.radacTimeByFrame[selectorById] = self.radacHeaderObj.radacTime[0, self.idpulse_range2]
421
422 selectorById = self.radacHeaderObj.pulseCount[0,self.idpulse_range1]
423
424 self.radacTimeByFrame[selectorById] = self.buffer_radactime[selectorById]
425
426 datablock = self.__setDataBlock()
427
428 return datablock
429
430 selectorById = self.radacHeaderObj.pulseCount[idrecord-1,self.idpulse_range1]
431 self.dataByFrame[selectorById,:,:] = self.dataset[idrecord-1, self.idpulse_range1, :, :]
432 self.radacTimeByFrame[selectorById] = self.radacHeaderObj.radacTime[idrecord-1, self.idpulse_range1]
433
434 selectorById = self.radacHeaderObj.pulseCount[idrecord,self.idpulse_range2]#data incompleta ultimo archivo de carpeta, verifica el record real segun la dimension del arreglo de datos
435 self.dataByFrame[selectorById,:,:] = self.dataset[idrecord, self.idpulse_range2, :, :]
436 self.radacTimeByFrame[selectorById] = self.radacHeaderObj.radacTime[idrecord, self.idpulse_range2]
437
438 datablock = self.__setDataBlock()
439
440 selectorById = self.radacHeaderObj.pulseCount[idrecord,self.idpulse_range1]
441 self.dataByFrame[selectorById,:,:] = self.dataset[idrecord, self.idpulse_range1, :, :]
442 self.buffer_radactime[selectorById] = self.radacHeaderObj.radacTime[idrecord, self.idpulse_range1]
443
444 return datablock
445
446
447 def readSamples(self,idrecord):
448 if self.flagIsNewFile:
449 self.dataByFrame = self.__setDataByFrame()
450 self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :]
451
452 #reading ranges
453 self.readRanges()
454 #reading dataset
455 self.dataset = self.__readDataSet()
456
457 self.flagIsNewFile = 0
458 self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :]
459 self.dataByFrame = self.dataset[idrecord, :, :, :]
460 datablock = self.__setDataBlock()
461 return datablock
462
463
464 def readDataBlock(self):
465
466 self.datablock = self.readSamples_version1(self.idrecord_count)
467 #self.datablock = self.readSamples(self.idrecord_count)
468 #print 'record:', self.idrecord_count
469
470 self.idrecord_count += 1
471 self.profileIndex = 0
472
473 if self.idrecord_count >= self.radacHeaderObj.nrecords:
474 self.idrecord_count = 0
475 self.flagIsNewFile = 1
476
477 def readNextBlock(self):
478
479 self.readDataBlock()
480
481 if self.flagIsNewFile:
482 self.__setNextFile()
483 pass
484
485 def __hasNotDataInBuffer(self):
486 #self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record
487 if self.profileIndex >= self.radacHeaderObj.npulses:
488 return 1
489 return 0
490
491 def printUTC(self):
492 print self.dataOut.utctime
493 print ''
494
495 def setObjProperties(self):
496 self.dataOut.heightList = self.rangeFromFile/1000.0 #km
497 self.dataOut.nProfiles = self.radacHeaderObj.npulses
498 self.dataOut.nRecords = self.radacHeaderObj.nrecords
499 self.dataOut.nBeams = self.radacHeaderObj.nbeams
500 self.dataOut.ippSeconds = self.ippSeconds_fromfile
501 self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
502 self.dataOut.frequency = self.frequency_h5file
503 self.dataOut.nBaud = None
504 self.dataOut.nCode = None
505 self.dataOut.code = None
506
507 self.dataOut.beamCodeDict = self.beamCodeDict
508 self.dataOut.beamRangeDict = self.beamRangeDict
509
510 def getData(self):
511
512 if self.flagNoMoreFiles:
513 self.dataOut.flagNoData = True
514 print 'Process finished'
515 return 0
516
517 if self.__hasNotDataInBuffer():
518 self.readNextBlock()
519
520
521 if self.datablock == None: # setear esta condicion cuando no hayan datos por leers
522 self.dataOut.flagNoData = True
523 return 0
524
525 self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1))
526
527 self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex]
528
529 self.dataOut.flagNoData = False
530
531 self.profileIndex += 1
532
533 return self.dataOut.data
534
535
536 def run(self, **kwargs):
537 if not(self.isConfig):
538 self.setup(**kwargs)
539 self.setObjProperties()
540 self.isConfig = True
541
542 self.getData()
Show file before | Show file after | Hide comments
@@ -0,0 +1,82
1 '''
2 @author: Daniel Suarez
3 '''
4
5 from jroproc_base import ProcessingUnit, Operation
6 from model.data.jroamisr import AMISR
7
8 class AMISRProc(ProcessingUnit):
9 def __init__(self):
10 ProcessingUnit.__init__(self)
11 self.objectDict = {}
12 self.dataOut = AMISR()
13
14 def run(self):
15 if self.dataIn.type == 'AMISR':
16 self.dataOut.copy(self.dataIn)
17
18
19 class PrintInfo(Operation):
20 def __init__(self):
21 pass
22
23 def run(self, dataOut):
24
25 print 'Number of Records by File: %d'%dataOut.nRecords
26 print 'Number of Pulses: %d'%dataOut.nProfiles
27 print 'Number of Samples by Pulse: %d'%len(dataOut.heightList)
28 print 'Ipp Seconds: %f'%dataOut.ippSeconds
29 print 'Number of Beams: %d'%dataOut.nBeams
30 print 'BeamCodes:'
31 beamStrList = ['Beam %d -> Code %d'%(k,v) for k,v in dataOut.beamCodeDict.items()]
32 for b in beamStrList:
33 print b
34
35
36 class BeamSelector(Operation):
37 profileIndex = None
38 nProfiles = None
39
40 def __init__(self):
41
42 self.profileIndex = 0
43
44 def incIndex(self):
45 self.profileIndex += 1
46
47 if self.profileIndex >= self.nProfiles:
48 self.profileIndex = 0
49
50 def isProfileInRange(self, minIndex, maxIndex):
51
52 if self.profileIndex < minIndex:
53 return False
54
55 if self.profileIndex > maxIndex:
56 return False
57
58 return True
59
60 def isProfileInList(self, profileList):
61
62 if self.profileIndex not in profileList:
63 return False
64
65 return True
66
67 def run(self, dataOut, beam=None):
68
69 dataOut.flagNoData = True
70 self.nProfiles = dataOut.nProfiles
71
72 if beam != None:
73 if self.isProfileInList(dataOut.beamRangeDict[beam]):
74 dataOut.flagNoData = False
75
76 self.incIndex()
77 return 1
78
79 else:
80 raise ValueError, "BeamSelector needs beam value"
81
82 return 0 No newline at end of file
Show file before | Show file after | Hide comments
@@ -723,60 +723,3 class Fits:
723 723
724 724 ltctime = property(getltctime, "I'm the 'ltctime' property")
725 725
726 class AMISR:
727 def __init__(self):
728 self.flagNoData = True
729 self.data = None
730 self.utctime = None
731 self.type = "AMISR"
732
733 #propiedades para compatibilidad con Voltages
734 self.timeZone = 300#timezone like jroheader, difference in minutes between UTC and localtime
735 self.dstFlag = 0#self.dataIn.dstFlag
736 self.errorCount = 0#self.dataIn.errorCount
737 self.useLocalTime = True#self.dataIn.useLocalTime
738
739 self.radarControllerHeaderObj = None#self.dataIn.radarControllerHeaderObj.copy()
740 self.systemHeaderObj = None#self.dataIn.systemHeaderObj.copy()
741 self.channelList = [0]#self.dataIn.channelList esto solo aplica para el caso de AMISR
742 self.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
743
744 self.flagTimeBlock = None#self.dataIn.flagTimeBlock
745 #self.utctime = #self.firstdatatime
746 self.flagDecodeData = None#self.dataIn.flagDecodeData #asumo q la data esta decodificada
747 self.flagDeflipData = None#self.dataIn.flagDeflipData #asumo q la data esta sin flip
748
749 self.nCohInt = 1#self.dataIn.nCohInt
750 self.nIncohInt = 1
751 self.ippSeconds = None#self.dataIn.ippSeconds, segun el filename/Setup/Tufile
752 self.windowOfFilter = None#self.dataIn.windowOfFilter
753
754 self.timeInterval = None#self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
755 self.frequency = None#self.dataIn.frequency
756 self.realtime = 0#self.dataIn.realtime
757
758 #actualizar en la lectura de datos
759 self.heightList = None#self.dataIn.heightList
760 self.nProfiles = None#Number of samples or nFFTPoints
761 self.nRecords = None
762 self.nBeams = None
763 self.nBaud = None#self.dataIn.nBaud
764 self.nCode = None#self.dataIn.nCode
765 self.code = None#self.dataIn.code
766
767 #consideracion para los Beams
768 self.beamCodeDict = None
769 self.beamRangeDict = None
770
771 def copy(self, inputObj=None):
772
773 if inputObj == None:
774 return copy.deepcopy(self)
775
776 for key in inputObj.__dict__.keys():
777 self.__dict__[key] = inputObj.__dict__[key]
778
779
780 def isEmpty(self):
781
782 return self.flagNoData No newline at end of file
Show file before | Show file after | Hide comments
@@ -8,7 +8,7 import time
8 8 import numpy
9 9 import fnmatch
10 10 import time, datetime
11 import h5py
11 #import h5py
12 12 import traceback
13 13
14 14 #try:
Show file before | Show file after | Hide comments
@@ -1,3 +1,4
1 1 from jroIO_voltage import *
2 2 from jroIO_spectra import *
3 3 from jroIO_heispectra import *
4 from jroIO_amisr import * No newline at end of file
Show file before | Show file after | Hide comments
@@ -2,6 +2,7 import numpy
2 2
3 3 from jroproc_base import ProcessingUnit, Operation
4 4 from model.data.jrodata import Spectra
5 from model.data.jrodata import hildebrand_sekhon
5 6
6 7 class SpectraProc(ProcessingUnit):
7 8
Show file before | Show file after | Hide comments
@@ -15,26 +15,32 class VoltageProc(ProcessingUnit):
15 15 self.flip = 1
16 16
17 17 def run(self):
18 self.dataOut.copy(self.dataIn)
18 if self.dataIn.type == 'AMISR':
19 self.__updateObjFromAmisrInput()
20
21 if self.dataIn.type == 'Voltage':
22 self.dataOut.copy(self.dataIn)
23
24 # self.dataOut.copy(self.dataIn)
19 25
20 # def __updateObjFromAmisrInput(self):
21 #
22 # self.dataOut.timeZone = self.dataIn.timeZone
23 # self.dataOut.dstFlag = self.dataIn.dstFlag
24 # self.dataOut.errorCount = self.dataIn.errorCount
25 # self.dataOut.useLocalTime = self.dataIn.useLocalTime
26 #
27 # self.dataOut.flagNoData = self.dataIn.flagNoData
28 # self.dataOut.data = self.dataIn.data
29 # self.dataOut.utctime = self.dataIn.utctime
30 # self.dataOut.channelList = self.dataIn.channelList
31 # self.dataOut.timeInterval = self.dataIn.timeInterval
32 # self.dataOut.heightList = self.dataIn.heightList
33 # self.dataOut.nProfiles = self.dataIn.nProfiles
34 #
35 # self.dataOut.nCohInt = self.dataIn.nCohInt
36 # self.dataOut.ippSeconds = self.dataIn.ippSeconds
37 # self.dataOut.frequency = self.dataIn.frequency
26 def __updateObjFromAmisrInput(self):
27
28 self.dataOut.timeZone = self.dataIn.timeZone
29 self.dataOut.dstFlag = self.dataIn.dstFlag
30 self.dataOut.errorCount = self.dataIn.errorCount
31 self.dataOut.useLocalTime = self.dataIn.useLocalTime
32
33 self.dataOut.flagNoData = self.dataIn.flagNoData
34 self.dataOut.data = self.dataIn.data
35 self.dataOut.utctime = self.dataIn.utctime
36 self.dataOut.channelList = self.dataIn.channelList
37 self.dataOut.timeInterval = self.dataIn.timeInterval
38 self.dataOut.heightList = self.dataIn.heightList
39 self.dataOut.nProfiles = self.dataIn.nProfiles
40
41 self.dataOut.nCohInt = self.dataIn.nCohInt
42 self.dataOut.ippSeconds = self.dataIn.ippSeconds
43 self.dataOut.frequency = self.dataIn.frequency
38 44 #
39 45 # pass#
40 46 #
Show file before | Show file after | Hide comments
@@ -1,3 +1,4
1 1 from jroproc_voltage import *
2 2 from jroproc_spectra import *
3 from jroproc_heispectra import * No newline at end of file
3 from jroproc_heispectra import *
4 from jroproc_amisr import * No newline at end of file
Show file before | Show file after | Hide comments
@@ -17,7 +17,7 path = os.path.join(os.environ['HOME'],'Documents/amisr')
17 17
18 18 figpath = os.path.join(os.environ['HOME'],'Pictures/amisr')
19 19
20 readUnitConfObj = controllerObj.addReadUnit(datatype='AMISR',
20 readUnitConfObj = controllerObj.addReadUnit(datatype='AMISRReader',
21 21 path=path,
22 22 startDate='2014/08/18',
23 23 endDate='2014/08/18',
@@ -26,19 +26,19 readUnitConfObj = controllerObj.addReadUnit(datatype='AMISR',
26 26 walk=1)
27 27
28 28 #AMISR Processing Unit
29 procUnitAMISRBeam0 = controllerObj.addProcUnit(datatype='AMISR', inputId=readUnitConfObj.getId())
29 procUnitAMISRBeam0 = controllerObj.addProcUnit(datatype='AMISRProc', inputId=readUnitConfObj.getId())
30 30
31 31 #Beam Selector
32 32 opObj11 = procUnitAMISRBeam0.addOperation(name='BeamSelector', optype='other')
33 33 opObj11.addParameter(name='beam', value='0', format='int')
34 34
35 35 #Voltage Processing Unit
36 procUnitConfObjBeam0 = controllerObj.addProcUnit(datatype='Voltage', inputId=procUnitAMISRBeam0.getId())
36 procUnitConfObjBeam0 = controllerObj.addProcUnit(datatype='VoltageProc', inputId=procUnitAMISRBeam0.getId())
37 37 #Coherent Integration
38 38 opObj11 = procUnitConfObjBeam0.addOperation(name='CohInt', optype='other')
39 39 opObj11.addParameter(name='n', value='128', format='int')
40 40 #Spectra Unit Processing, getting spectras with nProfiles and nFFTPoints
41 procUnitConfObjSpectraBeam0 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObjBeam0.getId())
41 procUnitConfObjSpectraBeam0 = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjBeam0.getId())
42 42 procUnitConfObjSpectraBeam0.addParameter(name='nFFTPoints', value=32, format='int')
43 43 procUnitConfObjSpectraBeam0.addParameter(name='nProfiles', value=32, format='int')
44 44 #Noise Estimation
@@ -66,7 +66,7 opObj11.addParameter(name='zmax', value='70', format='int')
66 66 #Save RTI
67 67 figfile0 = 'amisr_rti_beam0.png'
68 68 opObj11.addParameter(name='figpath', value=figpath, format='str')
69 opObj11.addParameter(name='figfile', value=figfile0, format='str')
69 #opObj11.addParameter(name='figfile', value=figfile0, format='str')
70 70
71 71
72 72 print "Escribiendo el archivo XML"
Show file before | Show file after | Hide comments
@@ -17,7 +17,7 path = os.path.join(os.environ['HOME'],'Documents/amisr') #'/home/signalchain/Do
17 17
18 18 figpath = os.path.join(os.environ['HOME'],'Pictures/amisr')
19 19
20 readUnitConfObj = controllerObj.addReadUnit(datatype='AMISR',
20 readUnitConfObj = controllerObj.addReadUnit(datatype='AMISRReader',
21 21 path=path,
22 22 startDate='2014/08/18',
23 23 endDate='2014/08/18',
@@ -25,7 +25,7 readUnitConfObj = controllerObj.addReadUnit(datatype='AMISR',
25 25 endTime='23:59:59',
26 26 walk=1)
27 27
28 procUnitAMISR = controllerObj.addProcUnit(datatype='AMISR', inputId=readUnitConfObj.getId())
28 procUnitAMISR = controllerObj.addProcUnit(datatype='AMISRProc', inputId=readUnitConfObj.getId())
29 29
30 30 opObj11 = procUnitAMISR.addOperation(name='PrintInfo', optype='other')
31 31
General Comments 0
You need to be logged in to leave comments. Login now