##// END OF EJS Templates
schain-jc
RSS
Nuevo Desarrollo SChain
Daniel Valdez -
r119:ca7117c99591
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,48
1
2 import copy
3 import numpy
4 from JROHeader import BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
5
6 class Data:
7 def __init__(self):
8 pass
9
10 def copy(self, inputObj=None):
11 if inputObj == None:
12 return copy.deepcopy(self)
13
14 for key in inputObj.__dict__.keys():
15 self.__dict__[key] = inputObj.__dict__[key]
16
17 def deepcopy(self):
18 return copy.deepcopy(self)
19
20 class JROData(Data):
21 data = None
22 # m_BasicHeader = BasicHeader()
23 # m_SystemHeader = SystemHeader()
24 # m_RadarControllerHeader = RadarControllerHeader()
25 # m_ProcessingHeader = ProcessingHeader()
26 type = None
27 dataType = None
28 heightList = None
29 channelIndexList = None
30 channelList = None
31 nHeights = None
32 nProfiles = None
33 nBlocksPerFile = None
34 nChannels = None
35 flagNoData = False
36 flagResetProcessing = False
37
38 def __init__(self):
39 raise ValueError, "This class has not been implemented"
40
41 # def updateHeaderFromObj(self):
42 # pass
43 #
44 #
45 # def updateObjFromHeader(self):
46 # pass
47
48
Show file before | Show file after | Hide comments
@@ -0,0 +1,27
1 import numpy
2 from JROData import JROData
3 # No deberia importar los Headers
4 class Voltage(JROData):
5 data = None
6 nCohInt = None
7
8 def __init__(self):
9 self.type = "Voltage"
10
11 def updateObjFromHeader(self):
12 xi = self.m_ProcessingHeader.firstHeight
13 step = self.m_ProcessingHeader.deltaHeight
14 xf = xi + self.m_ProcessingHeader.numHeights*step
15
16 self.heightList = numpy.arange(xi, xf, step)
17 self.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
18 self.channelList = numpy.arange(self.m_SystemHeader.numChannels)
19
20 self.nHeights = len(self.heightList)
21 self.nChannels = len(self.channelList)
22 self.nProfiles = self.m_ProcessingHeader.profilesPerBlock
23 self.nBlocksPerFile = self.m_ProcessingHeader.dataBlocksPerFile
24 self.nCohInt = self.m_ProcessingHeader.coherentInt
25
26 def updateHeaderFromObj(self):
27 pass No newline at end of file
Show file before | Show file after | Hide comments
1 NO CONTENT: new file 100644
NO CONTENT: new file 100644
Show file before | Show file after | Hide comments
@@ -0,0 +1,378
1 import os, sys
2 import glob
3 import time
4 import numpy
5 import fnmatch
6 import time, datetime
7
8 path = os.path.split(os.getcwd())[0]
9 sys.path.append(path)
10
11 from Model.JROHeader import *
12 from Model.JROData import JROData
13
14 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
15 """
16 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
17
18 Inputs:
19 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
20
21 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
22 segundos contados desde 01/01/1970.
23 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
24 segundos contados desde 01/01/1970.
25
26 Return:
27 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
28 fecha especificado, de lo contrario retorna False.
29
30 Excepciones:
31 Si el archivo no existe o no puede ser abierto
32 Si la cabecera no puede ser leida.
33
34 """
35 m_BasicHeader = BasicHeader()
36
37 try:
38 fp = open(filename,'rb')
39 except:
40 raise IOError, "The file %s can't be opened" %(filename)
41
42 sts = m_BasicHeader.read(fp)
43 fp.close()
44
45 if not(sts):
46 print "Skipping the file %s because it has not a valid header" %(filename)
47 return 0
48
49 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds > m_BasicHeader.utc)):
50 return 0
51
52 return 1
53
54
55
56
57 class JRODataIO:
58 c = 3E8
59 m_BasicHeader = BasicHeader()
60 m_SystemHeader = SystemHeader()
61 m_RadarControllerHeader = RadarControllerHeader()
62 m_ProcessingHeader = ProcessingHeader()
63 online = 0
64 dataType = None
65 pathList = []
66 filenameList = []
67 filename = None
68 ext = None
69 fileIndex = None
70 flagNoMoreFiles = 0
71 flagIsNewFile = 1
72 flagResetProcessing = 0
73 flagIsNewBlock = 0
74 fp = None
75 firstHeaderSize = 0
76 basicHeaderSize = 24
77 fileSize = None
78 ippSeconds = None
79 fileSizeByHeader = None
80 def __init__(self):
81 pass
82
83 class JRODataReader(JRODataIO):
84 def __init__(self):
85 pass
86
87 def createObjByDefault(self):
88 """
89
90 """
91 raise ValueError, "This method has not been implemented"
92
93 def getBlockDimension(self):
94
95 raise ValueError, "No implemented"
96
97 def __searchFilesOffLine(self,
98 path,
99 startDate,
100 endDate,
101 startTime=datetime.time(0,0,0),
102 endTime=datetime.time(23,59,59),
103 set=None,
104 expLabel="",
105 ext=".r"):
106 dirList = []
107 for thisPath in os.listdir(path):
108 if os.path.isdir(os.path.join(path,thisPath)):
109 dirList.append(thisPath)
110
111 if not(dirList):
112 return None, None
113
114 pathList = []
115 dateList = []
116
117 thisDate = startDate
118
119 while(thisDate <= endDate):
120 year = thisDate.timetuple().tm_year
121 doy = thisDate.timetuple().tm_yday
122
123 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
124 if len(match) == 0:
125 thisDate += datetime.timedelta(1)
126 continue
127
128 pathList.append(os.path.join(path,match[0],expLabel))
129 dateList.append(thisDate)
130 thisDate += datetime.timedelta(1)
131
132 filenameList = []
133 for index in range(len(pathList)):
134
135 thisPath = pathList[index]
136 fileList = glob.glob1(thisPath, "*%s" %ext)
137 fileList.sort()
138
139 #Busqueda de datos en el rango de horas indicados
140 thisDate = dateList[index]
141 startDT = datetime.datetime.combine(thisDate, startTime)
142 endDT = datetime.datetime.combine(thisDate, endTime)
143
144 startUtSeconds = time.mktime(startDT.timetuple())
145 endUtSeconds = time.mktime(endDT.timetuple())
146
147 for file in fileList:
148
149 filename = os.path.join(thisPath,file)
150
151 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
152 filenameList.append(filename)
153
154 if not(filenameList):
155 return None, None
156
157 self.filenameList = filenameList
158
159 return pathList, filenameList
160
161 def setup(self,dataOutObj=None,
162 path=None,startDate=None,
163 endDate=None,
164 startTime=datetime.time(0,0,0),
165 endTime=datetime.time(23,59,59),
166 set=0,
167 expLabel = "",
168 ext = None,
169 online = 0):
170
171 if path == None:
172 raise ValueError, "The path is not valid"
173
174 if ext == None:
175 ext = self.ext
176
177 if dataOutObj == None:
178 dataOutObj = self.createObjByDefault()
179
180 self.dataOutObj = dataOutObj
181
182 if online:
183 pass
184
185 else:
186 print "Searching file in offline mode"
187 pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
188 if not(pathList):
189 print "No files in range: %s - %s"%(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
190 return None
191 self.fileIndex = -1
192 self.pathList = pathList
193 self.filenameList = filenameList
194
195 self.online = online
196 ext = ext.lower()
197 self.ext = ext
198
199 if not(self.setNextFile()):
200 if (startDate!=None) and (endDate!=None):
201 print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
202 elif startDate != None:
203 print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
204 else:
205 print "No files"
206
207 return None
208
209 self.updateDataHeader()
210
211 return self.dataOutObj
212
213 def __setNextFileOffline(self):
214 idFile = self.fileIndex
215
216 while (True):
217 idFile += 1
218 if not(idFile < len(self.filenameList)):
219 self.flagNoMoreFiles = 1
220 print "No more Files"
221 return 0
222
223 filename = self.filenameList[idFile]
224
225 if not(self.__verifyFile(filename)):
226 continue
227
228 fileSize = os.path.getsize(filename)
229 fp = open(filename,'rb')
230 break
231
232 self.flagIsNewFile = 1
233 self.fileIndex = idFile
234 self.filename = filename
235 self.fileSize = fileSize
236 self.fp = fp
237
238 print "Setting the file: %s"%self.filename
239
240 return 1
241
242
243
244 def setNextFile(self):
245 if self.fp != None:
246 self.fp.close()
247
248 if self.online:
249 newFile = self.__setNextFileOnline()
250 else:
251 newFile = self.__setNextFileOffline()
252
253 if not(newFile):
254 return 0
255
256 self.__readFirstHeader()
257 self.nReadBlocks = 0
258 return 1
259
260 def __rdProcessingHeader(self, fp=None):
261 if fp == None:
262 fp = self.fp
263
264 self.m_ProcessingHeader.read(fp)
265
266 def __rdRadarControllerHeader(self, fp=None):
267 if fp == None:
268 fp = self.fp
269
270 self.m_RadarControllerHeader.read(fp)
271
272 def __rdSystemHeader(self, fp=None):
273 if fp == None:
274 fp = self.fp
275
276 self.m_SystemHeader.read(fp)
277
278 def __rdBasicHeader(self, fp=None):
279 if fp == None:
280 fp = self.fp
281
282 self.m_BasicHeader.read(fp)
283
284
285 def __readFirstHeader(self):
286 self.__rdBasicHeader()
287 self.__rdSystemHeader()
288 self.__rdRadarControllerHeader()
289 self.__rdProcessingHeader()
290
291 self.firstHeaderSize = self.m_BasicHeader.size
292
293 datatype = int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
294 if datatype == 0:
295 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
296 elif datatype == 1:
297 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
298 elif datatype == 2:
299 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
300 elif datatype == 3:
301 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
302 elif datatype == 4:
303 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
304 elif datatype == 5:
305 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
306 else:
307 raise ValueError, 'Data type was not defined'
308
309 self.dataType = datatype_str
310 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
311 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
312 # self.dataOutObj.channelList = numpy.arange(self.m_SystemHeader.numChannels)
313 # self.dataOutObj.channelIndexList = numpy.arange(self.m_SystemHeader.numChannels)
314 self.getBlockDimension()
315
316
317 def __verifyFile(self, filename, msgFlag=True):
318 msg = None
319 try:
320 fp = open(filename, 'rb')
321 currentPosition = fp.tell()
322 except:
323 if msgFlag:
324 print "The file %s can't be opened" % (filename)
325 return False
326
327 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
328
329 if neededSize == 0:
330 m_BasicHeader = BasicHeader()
331 m_SystemHeader = SystemHeader()
332 m_RadarControllerHeader = RadarControllerHeader()
333 m_ProcessingHeader = ProcessingHeader()
334
335 try:
336 if not( m_BasicHeader.read(fp) ): raise ValueError
337 if not( m_SystemHeader.read(fp) ): raise ValueError
338 if not( m_RadarControllerHeader.read(fp) ): raise ValueError
339 if not( m_ProcessingHeader.read(fp) ): raise ValueError
340 data_type = int(numpy.log2((m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
341
342 neededSize = m_ProcessingHeader.blockSize + m_BasicHeader.size
343
344 except:
345 if msgFlag:
346 print "\tThe file %s is empty or it hasn't enough data" % filename
347
348 fp.close()
349 return False
350 else:
351 msg = "\tSkipping the file %s due to it hasn't enough data" %filename
352
353 fp.close()
354 fileSize = os.path.getsize(filename)
355 currentSize = fileSize - currentPosition
356 if currentSize < neededSize:
357 if msgFlag and (msg != None):
358 print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
359 return False
360
361 return True
362
363
364
365 def updateDataHeader(self):
366 self.dataOutObj.m_BasicHeader = self.m_BasicHeader.copy()
367 self.dataOutObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
368 self.dataOutObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
369 self.dataOutObj.m_SystemHeader = self.m_SystemHeader.copy()
370 self.dataOutObj.dataType = self.dataType
371 self.dataOutObj.updateObjFromHeader() # actualiza los atributos del objeto de salida de la clase JROData
372
373
374
375
376
377
378
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (505 lines changed) Show them Hide them
@@ -0,0 +1,505
1 '''
2 Created on 23/01/2012
3
4 @author $Author: vsarmiento $
5 @version $Id: HeaderIO.py 37 2012-03-26 22:55:13Z vsarmiento $
6 '''
7
8 import numpy
9 import copy
10
11 class Header:
12
13 def __init__(self):
14 raise
15
16 def copy(self):
17 return copy.deepcopy(self)
18
19 def read():
20 pass
21
22 def write():
23 pass
24
25 class BasicHeader(Header):
26
27 size = None
28 version = None
29 dataBlock = None
30 utc = None
31 miliSecond = None
32 timeZone = None
33 dstFlag = None
34 errorCount = None
35 struct = None
36
37 def __init__(self):
38 self.size = 0
39 self.version = 0
40 self.dataBlock = 0
41 self.utc = 0
42 self.miliSecond = 0
43 self.timeZone = 0
44 self.dstFlag = 0
45 self.errorCount = 0
46 self.struct = numpy.dtype([
47 ('nSize','<u4'),
48 ('nVersion','<u2'),
49 ('nDataBlockId','<u4'),
50 ('nUtime','<u4'),
51 ('nMilsec','<u2'),
52 ('nTimezone','<i2'),
53 ('nDstflag','<i2'),
54 ('nErrorCount','<u4')
55 ])
56
57
58 def read(self, fp):
59 try:
60 header = numpy.fromfile(fp, self.struct,1)
61 self.size = header['nSize'][0]
62 self.version = header['nVersion'][0]
63 self.dataBlock = header['nDataBlockId'][0]
64 self.utc = header['nUtime'][0]
65 self.miliSecond = header['nMilsec'][0]
66 self.timeZone = header['nTimezone'][0]
67 self.dstFlag = header['nDstflag'][0]
68 self.errorCount = header['nErrorCount'][0]
69 except:
70 return 0
71
72 return 1
73
74 def write(self, fp):
75 headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
76 header = numpy.array(headerTuple,self.struct)
77 header.tofile(fp)
78
79 return 1
80
81 class SystemHeader(Header):
82
83 size = None
84 numSamples = None
85 numProfiles = None
86 numChannels = None
87 adcResolution = None
88 pciDioBusWidth = None
89 struct = None
90
91 def __init__(self):
92 self.size = 0
93 self.numSamples = 0
94 self.numProfiles = 0
95 self.numChannels = 0
96 self.adcResolution = 0
97 self.pciDioBusWidth = 0
98 self.struct = numpy.dtype([
99 ('nSize','<u4'),
100 ('nNumSamples','<u4'),
101 ('nNumProfiles','<u4'),
102 ('nNumChannels','<u4'),
103 ('nADCResolution','<u4'),
104 ('nPCDIOBusWidth','<u4'),
105 ])
106
107
108 def read(self, fp):
109 try:
110 header = numpy.fromfile(fp,self.struct,1)
111 self.size = header['nSize'][0]
112 self.numSamples = header['nNumSamples'][0]
113 self.numProfiles = header['nNumProfiles'][0]
114 self.numChannels = header['nNumChannels'][0]
115 self.adcResolution = header['nADCResolution'][0]
116 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
117 except:
118 return 0
119
120 return 1
121
122 def write(self, fp):
123 headerTuple = (self.size,self.numSamples,self.numProfiles,self.numChannels,self.adcResolution,self.pciDioBusWidth)
124 header = numpy.array(headerTuple,self.struct)
125 header.tofile(fp)
126
127 return 1
128
129 class RadarControllerHeader(Header):
130
131 size = None
132 expType = None
133 nTx = None
134 ipp = None
135 txA = None
136 txB = None
137 numWindows = None
138 numTaus = None
139 codeType = None
140 line6Function = None
141 line5Function = None
142 fClock = None
143 prePulseBefore = None
144 prePulserAfter = None
145 rangeIpp = None
146 rangeTxA = None
147 rangeTxB = None
148 struct = None
149
150 def __init__(self):
151 self.size = 0
152 self.expType = 0
153 self.nTx = 0
154 self.ipp = 0
155 self.txA = 0
156 self.txB = 0
157 self.numWindows = 0
158 self.numTaus = 0
159 self.codeType = 0
160 self.line6Function = 0
161 self.line5Function = 0
162 self.fClock = 0
163 self.prePulseBefore = 0
164 self.prePulserAfter = 0
165 self.rangeIpp = 0
166 self.rangeTxA = 0
167 self.rangeTxB = 0
168 self.struct = numpy.dtype([
169 ('nSize','<u4'),
170 ('nExpType','<u4'),
171 ('nNTx','<u4'),
172 ('fIpp','<f4'),
173 ('fTxA','<f4'),
174 ('fTxB','<f4'),
175 ('nNumWindows','<u4'),
176 ('nNumTaus','<u4'),
177 ('nCodeType','<u4'),
178 ('nLine6Function','<u4'),
179 ('nLine5Function','<u4'),
180 ('fClock','<f4'),
181 ('nPrePulseBefore','<u4'),
182 ('nPrePulseAfter','<u4'),
183 ('sRangeIPP','<a20'),
184 ('sRangeTxA','<a20'),
185 ('sRangeTxB','<a20'),
186 ])
187
188 self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
189
190 self.samplingWindow = None
191 self.numHeights = None
192 self.firstHeight = None
193 self.deltaHeight = None
194 self.samplesWin = None
195
196 self.numCode = None
197 self.numBaud = None
198 self.code = None
199 self.flip1 = None
200 self.flip2 = None
201
202 self.dynamic = numpy.array([],numpy.dtype('byte'))
203
204
205 def read(self, fp):
206 try:
207 startFp = fp.tell()
208 header = numpy.fromfile(fp,self.struct,1)
209 self.size = header['nSize'][0]
210 self.expType = header['nExpType'][0]
211 self.nTx = header['nNTx'][0]
212 self.ipp = header['fIpp'][0]
213 self.txA = header['fTxA'][0]
214 self.txB = header['fTxB'][0]
215 self.numWindows = header['nNumWindows'][0]
216 self.numTaus = header['nNumTaus'][0]
217 self.codeType = header['nCodeType'][0]
218 self.line6Function = header['nLine6Function'][0]
219 self.line5Function = header['nLine5Function'][0]
220 self.fClock = header['fClock'][0]
221 self.prePulseBefore = header['nPrePulseBefore'][0]
222 self.prePulserAfter = header['nPrePulseAfter'][0]
223 self.rangeIpp = header['sRangeIPP'][0]
224 self.rangeTxA = header['sRangeTxA'][0]
225 self.rangeTxB = header['sRangeTxB'][0]
226 # jump Dynamic Radar Controller Header
227 jumpFp = self.size - 116
228 self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
229 #pointer backward to dynamic header and read
230 backFp = fp.tell() - jumpFp
231 fp.seek(backFp)
232
233 self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.numWindows)
234 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
235 self.firstHeight = self.samplingWindow['h0']
236 self.deltaHeight = self.samplingWindow['dh']
237 self.samplesWin = self.samplingWindow['nsa']
238
239 self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
240
241 if self.codeType != 0:
242 self.numCode = numpy.fromfile(fp,'<u4',1)
243 self.numBaud = numpy.fromfile(fp,'<u4',1)
244 self.code = numpy.empty([self.numCode,self.numBaud],dtype='u1')
245 tempList = []
246 for ic in range(self.numCode):
247 temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.numBaud/32.))
248 tempList.append(temp)
249 self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.numBaud:]
250 self.code = 2.0*self.code - 1.0
251
252 if self.line5Function == RCfunction.FLIP:
253 self.flip1 = numpy.fromfile(fp,'<u4',1)
254
255 if self.line6Function == RCfunction.FLIP:
256 self.flip2 = numpy.fromfile(fp,'<u4',1)
257
258 endFp = self.size + startFp
259 jumpFp = endFp - fp.tell()
260 if jumpFp > 0:
261 fp.seek(jumpFp)
262
263 except:
264 return 0
265
266 return 1
267
268 def write(self, fp):
269 headerTuple = (self.size,
270 self.expType,
271 self.nTx,
272 self.ipp,
273 self.txA,
274 self.txB,
275 self.numWindows,
276 self.numTaus,
277 self.codeType,
278 self.line6Function,
279 self.line5Function,
280 self.fClock,
281 self.prePulseBefore,
282 self.prePulserAfter,
283 self.rangeIpp,
284 self.rangeTxA,
285 self.rangeTxB)
286
287 header = numpy.array(headerTuple,self.struct)
288 header.tofile(fp)
289
290 dynamic = self.dynamic
291 dynamic.tofile(fp)
292
293 return 1
294
295
296
297 class ProcessingHeader(Header):
298
299 size = None
300 dataType = None
301 blockSize = None
302 profilesPerBlock = None
303 dataBlocksPerFile = None
304 numWindows = None
305 processFlags = None
306 coherentInt = None
307 incoherentInt = None
308 totalSpectra = None
309 struct = None
310 flag_dc = None
311 flag_cspc = None
312
313 def __init__(self):
314 self.size = 0
315 self.dataType = 0
316 self.blockSize = 0
317 self.profilesPerBlock = 0
318 self.dataBlocksPerFile = 0
319 self.numWindows = 0
320 self.processFlags = 0
321 self.coherentInt = 0
322 self.incoherentInt = 0
323 self.totalSpectra = 0
324 self.struct = numpy.dtype([
325 ('nSize','<u4'),
326 ('nDataType','<u4'),
327 ('nSizeOfDataBlock','<u4'),
328 ('nProfilesperBlock','<u4'),
329 ('nDataBlocksperFile','<u4'),
330 ('nNumWindows','<u4'),
331 ('nProcessFlags','<u4'),
332 ('nCoherentIntegrations','<u4'),
333 ('nIncoherentIntegrations','<u4'),
334 ('nTotalSpectra','<u4')
335 ])
336 self.samplingWindow = 0
337 self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
338 self.numHeights = 0
339 self.firstHeight = 0
340 self.deltaHeight = 0
341 self.samplesWin = 0
342 self.spectraComb = 0
343 self.numCode = 0
344 self.code = 0
345 self.numBaud = 0
346 self.shif_fft = False
347 self.flag_dc = False
348 self.flag_cspc = False
349
350 def read(self, fp):
351 try:
352 header = numpy.fromfile(fp,self.struct,1)
353 self.size = header['nSize'][0]
354 self.dataType = header['nDataType'][0]
355 self.blockSize = header['nSizeOfDataBlock'][0]
356 self.profilesPerBlock = header['nProfilesperBlock'][0]
357 self.dataBlocksPerFile = header['nDataBlocksperFile'][0]
358 self.numWindows = header['nNumWindows'][0]
359 self.processFlags = header['nProcessFlags']
360 self.coherentInt = header['nCoherentIntegrations'][0]
361 self.incoherentInt = header['nIncoherentIntegrations'][0]
362 self.totalSpectra = header['nTotalSpectra'][0]
363 self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.numWindows)
364 self.numHeights = numpy.sum(self.samplingWindow['nsa'])
365 self.firstHeight = self.samplingWindow['h0']
366 self.deltaHeight = self.samplingWindow['dh']
367 self.samplesWin = self.samplingWindow['nsa']
368 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
369
370 if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
371 self.numCode = numpy.fromfile(fp,'<u4',1)
372 self.numBaud = numpy.fromfile(fp,'<u4',1)
373 self.code = numpy.fromfile(fp,'<f4',self.numCode*self.numBaud).reshape(self.numBaud,self.numCode)
374
375 if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
376 self.shif_fft = True
377 else:
378 self.shif_fft = False
379
380 if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
381 self.flag_dc = True
382
383 nChannels = 0
384 nPairs = 0
385 pairList = []
386
387 for i in range( 0, self.totalSpectra*2, 2 ):
388 if self.spectraComb[i] == self.spectraComb[i+1]:
389 nChannels = nChannels + 1 #par de canales iguales
390 else:
391 nPairs = nPairs + 1 #par de canales diferentes
392 pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
393
394 self.flag_cspc = False
395 if nPairs > 0:
396 self.flag_cspc = True
397
398 except:
399 return 0
400
401 return 1
402
403 def write(self, fp):
404 headerTuple = (self.size,
405 self.dataType,
406 self.blockSize,
407 self.profilesPerBlock,
408 self.dataBlocksPerFile,
409 self.numWindows,
410 self.processFlags,
411 self.coherentInt,
412 self.incoherentInt,
413 self.totalSpectra)
414
415 header = numpy.array(headerTuple,self.struct)
416 header.tofile(fp)
417
418 if self.numWindows != 0:
419 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
420 samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
421 samplingWindow.tofile(fp)
422
423
424 if self.totalSpectra != 0:
425 spectraComb = numpy.array([],numpy.dtype('u1'))
426 spectraComb = self.spectraComb
427 spectraComb.tofile(fp)
428
429
430 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
431 numCode = self.numCode
432 numCode.tofile(fp)
433
434 numBaud = self.numBaud
435 numBaud.tofile(fp)
436
437 code = self.code.reshape(numCode*numBaud)
438 code.tofile(fp)
439
440 return 1
441
442 class RCfunction:
443 NONE=0
444 FLIP=1
445 CODE=2
446 SAMPLING=3
447 LIN6DIV256=4
448 SYNCHRO=5
449
450 class nCodeType:
451 NONE=0
452 USERDEFINE=1
453 BARKER2=2
454 BARKER3=3
455 BARKER4=4
456 BARKER5=5
457 BARKER7=6
458 BARKER11=7
459 BARKER13=8
460 AC128=9
461 COMPLEMENTARYCODE2=10
462 COMPLEMENTARYCODE4=11
463 COMPLEMENTARYCODE8=12
464 COMPLEMENTARYCODE16=13
465 COMPLEMENTARYCODE32=14
466 COMPLEMENTARYCODE64=15
467 COMPLEMENTARYCODE128=16
468 CODE_BINARY28=17
469
470 class PROCFLAG:
471 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
472 DECODE_DATA = numpy.uint32(0x00000002)
473 SPECTRA_CALC = numpy.uint32(0x00000004)
474 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
475 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
476 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
477
478 DATATYPE_CHAR = numpy.uint32(0x00000040)
479 DATATYPE_SHORT = numpy.uint32(0x00000080)
480 DATATYPE_LONG = numpy.uint32(0x00000100)
481 DATATYPE_INT64 = numpy.uint32(0x00000200)
482 DATATYPE_FLOAT = numpy.uint32(0x00000400)
483 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
484
485 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
486 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
487 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
488
489 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
490 DEFLIP_DATA = numpy.uint32(0x00010000)
491 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
492
493 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
494 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
495 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
496 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
497 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
498
499 EXP_NAME_ESP = numpy.uint32(0x00200000)
500 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
501
502 OPERATION_MASK = numpy.uint32(0x0000003F)
503 DATATYPE_MASK = numpy.uint32(0x00000FC0)
504 DATAARRANGE_MASK = numpy.uint32(0x00007000)
505 ACQ_SYS_MASK = numpy.uint32(0x001C0000) No newline at end of file
Show file before | Show file after | Hide comments
@@ -0,0 +1,41
1
2 import os, sys
3 import numpy
4 import glob
5 import fnmatch
6 import time, datetime
7
8 path = os.path.split(os.getcwd())[0]
9 sys.path.append(path)
10
11 from Model.JROHeader import *
12 from Model.Voltage import Voltage
13
14 from IO.JRODataIO import JRODataReader
15
16
17 class VoltageReader(JRODataReader):
18 dataOutObj = None
19 datablock = None
20 ext = ".r"
21 optchar = "D"
22
23 def __init__(self, dataOutObj=None):
24 self.datablock = None
25 #Por herencia no necesito instanciar nuevamente estos objetos
26 #self.m_BasicHeader = BasicHeader()
27 #self.m_SystemHeader = SystemHeader()
28 #self.m_RadarControllerHeader = RadarControllerHeader()
29 #self.m_ProcessingHeader = ProcessingHeader()
30 self.online = 0
31
32 def createObjByDefault(self):
33 dataObj = Voltage()
34
35 return dataObj
36
37 def getBlockDimension(self):
38 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
39 self.blocksize = pts2read
40
41
Show file before | Show file after | Hide comments
1 NO CONTENT: new file 100644
NO CONTENT: new file 100644
Show file before | Show file after | Hide comments
@@ -0,0 +1,133
1 import os
2 import sys
3 import numpy
4
5 path = os.path.split(os.getcwd())[0]
6 sys.path.append(path)
7
8 from Model.Voltage import Voltage
9
10
11 class VoltageProcessor:
12 dataInObj = None
13 dataOutObj = None
14 integratorObjIndex = None
15 writerObjIndex = None
16 integratorObjList = None
17 writerObjList = None
18
19 def __init__(self):
20 self.integratorObjIndex = None
21 self.writerObjIndex = None
22 self.integratorObjList = []
23 self.writerObjList = []
24
25 def setup(self,dataInObj=None,dataOutObj=None):
26 self.dataInObj = dataInObj
27
28 if self.dataOutObj == None:
29 dataOutObj = Voltage()
30
31 self.dataOutObj = dataOutObj
32
33 return self.dataOutObj
34
35 def init(self):
36 self.integratorObjIndex = 0
37 self.writerObjIndex = 0
38 # No necesita copiar en cada init() los atributos de dataInObj
39 # la copia deberia hacerse por cada nuevo bloque de datos
40
41 def addIntegrator(self,N,timeInterval):
42 objCohInt = CoherentIntegrator(N,timeInterval)
43 self.integratorObjList.append(objCohInt)
44
45 def addWriter(self):
46 pass
47
48 def integrator(self, N=None, timeInterval=None):
49 if self.dataOutObj.flagNoData:
50 return 0
51 if len(self.integratorObjList) <= self.integratorObjIndex:
52 self.addIntegrator(N,timeInterval)
53
54 myCohIntObj = self.integratorObjList[self.integratorObjIndex]
55 myCohIntObj.exe(data=self.dataOutObj.data,timeOfData=None)
56
57 pass
58
59 def writeData(self):
60 pass
61
62 class CoherentIntegrator:
63
64 integ_counter = None
65 data = None
66 navg = None
67 buffer = None
68 nCohInt = None
69
70 def __init__(self, N=None,timeInterval=None):
71
72 self.data = None
73 self.navg = None
74 self.buffer = None
75 self.timeOut = None
76 self.exitCondition = False
77 self.isReady = False
78 self.nCohInt = N
79 self.integ_counter = 0
80 if timeInterval!=None:
81 self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
82
83 if ((timeInterval==None) and (N==None)):
84 raise ValueError, "N = None ; timeInterval = None"
85
86 if timeInterval == None:
87 self.timeFlag = False
88 else:
89 self.timeFlag = True
90
91 def exe(self, data, timeOfData):
92
93 if self.timeFlag:
94 if self.timeOut == None:
95 self.timeOut = timeOfData + self.timeIntervalInSeconds
96
97 if timeOfData < self.timeOut:
98 if self.buffer == None:
99 self.buffer = data
100 else:
101 self.buffer = self.buffer + data
102 self.integ_counter += 1
103 else:
104 self.exitCondition = True
105
106 else:
107 if self.integ_counter < self.nCohInt:
108 if self.buffer == None:
109 self.buffer = data
110 else:
111 self.buffer = self.buffer + data
112
113 self.integ_counter += 1
114
115 if self.integ_counter == self.nCohInt:
116 self.exitCondition = True
117
118 if self.exitCondition:
119 self.data = self.buffer
120 self.navg = self.integ_counter
121 self.isReady = True
122 self.buffer = None
123 self.timeOut = None
124 self.integ_counter = 0
125 self.exitCondition = False
126
127 if self.timeFlag:
128 self.buffer = data
129 self.timeOut = timeOfData + self.timeIntervalInSeconds
130 else:
131 self.isReady = False
132
133
Show file before | Show file after | Hide comments
1 NO CONTENT: new file 100644
NO CONTENT: new file 100644
Show file before | Show file after | Hide comments
@@ -0,0 +1,64
1
2 import os, sys
3 import time, datetime
4
5 path = os.path.split(os.getcwd())[0]
6 sys.path.append(path)
7
8 from Data.Voltage import Voltage
9 from IO.VoltageIO import *
10
11 from Processing.VoltageProcessor import *
12
13
14
15 class TestSChain():
16
17 def __init__(self):
18 self.setValues()
19 self.createObjects()
20 self.testSChain()
21
22 def setValues(self):
23 self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
24
25 self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
26
27 self.startDate = datetime.date(2009,1,17)
28 self.endDate = datetime.date(2009,1,17)
29
30 self.startTime = datetime.time(0,0,0)
31 self.endTime = datetime.time(14,1,1)
32
33 def createObjects(self):
34 self.readerObj = VoltageReader()
35 self.voltProcObj = VoltageProcessor()
36
37 self.voltObj1 = self.readerObj.setup(
38 path = self.path,
39 startDate = self.startDate,
40 endDate = self.endDate,
41 startTime = self.startTime,
42 endTime = self.endTime,
43 expLabel = '',
44 online = 0)
45
46
47
48 def testSChain(self):
49
50 ini = time.time()
51
52 while(True):
53 self.readerObj.getData()
54
55 if self.readerObj.flagNoMoreFiles:
56 break
57
58 if self.readerObj.flagIsNewBlock:
59 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
60 datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
61
62
63 if __name__ == '__main__':
64 TestSChain() No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now