| @@ -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 | ||
| @@ -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 | |
|
|
1 | NO CONTENT: new file 100644 |
| @@ -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 | ||
| 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 | |
| @@ -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 | ||
|
|
1 | NO CONTENT: new file 100644 |
| @@ -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 | ||
|
|
1 | NO CONTENT: new file 100644 |
| @@ -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