| @@ -1,781 +1,815 | |||||
| 1 | ''' |
|
1 | ''' | |
| 2 | Created on Jul 3, 2014 |
|
2 | Created on Jul 3, 2014 | |
| 3 |
|
3 | |||
| 4 | @author: roj-com0419 |
|
4 | @author: roj-com0419 | |
| 5 | ''' |
|
5 | ''' | |
| 6 |
|
6 | |||
| 7 | import os,sys |
|
7 | import os,sys | |
| 8 | import time,datetime |
|
8 | import time,datetime | |
| 9 | import h5py |
|
9 | import h5py | |
| 10 | import numpy |
|
10 | import numpy | |
| 11 | import fnmatch |
|
11 | import fnmatch | |
| 12 | import re |
|
12 | import re | |
| 13 | import stuffr |
|
13 | import stuffr | |
| 14 |
|
14 | |||
| 15 | from model.data.jroheaderIO import RadarControllerHeader, SystemHeader |
|
15 | from model.data.jroheaderIO import RadarControllerHeader, SystemHeader | |
| 16 | from model.data.jrodata import Voltage |
|
16 | from model.data.jrodata import Voltage | |
| 17 | from model.proc.jroproc_base import ProcessingUnit, Operation |
|
17 | from model.proc.jroproc_base import ProcessingUnit, Operation | |
| 18 |
|
18 | |||
| 19 |
|
19 | |||
| 20 | def isNumber(str): |
|
20 | def isNumber(str): | |
| 21 | """ |
|
21 | """ | |
| 22 | Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero. |
|
22 | Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero. | |
| 23 |
|
23 | |||
| 24 | Excepciones: |
|
24 | Excepciones: | |
| 25 | Si un determinado string no puede ser convertido a numero |
|
25 | Si un determinado string no puede ser convertido a numero | |
| 26 | Input: |
|
26 | Input: | |
| 27 | str, string al cual se le analiza para determinar si convertible a un numero o no |
|
27 | str, string al cual se le analiza para determinar si convertible a un numero o no | |
| 28 |
|
28 | |||
| 29 | Return: |
|
29 | Return: | |
| 30 | True : si el string es uno numerico |
|
30 | True : si el string es uno numerico | |
| 31 | False : no es un string numerico |
|
31 | False : no es un string numerico | |
| 32 | """ |
|
32 | """ | |
| 33 | try: |
|
33 | try: | |
| 34 | float( str ) |
|
34 | float( str ) | |
| 35 | return True |
|
35 | return True | |
| 36 | except: |
|
36 | except: | |
| 37 | return False |
|
37 | return False | |
| 38 |
|
38 | |||
| 39 | def getFileFromSet(path, ext, set): |
|
39 | def getFileFromSet(path, ext, set): | |
| 40 | validFilelist = [] |
|
40 | validFilelist = [] | |
| 41 | fileList = os.listdir(path) |
|
41 | fileList = os.listdir(path) | |
| 42 |
|
42 | |||
| 43 | # 0 1234 567 89A BCDE |
|
43 | # 0 1234 567 89A BCDE | |
| 44 | # H YYYY DDD SSS .ext |
|
44 | # H YYYY DDD SSS .ext | |
| 45 |
|
45 | |||
| 46 | for thisFile in fileList: |
|
46 | for thisFile in fileList: | |
| 47 | try: |
|
47 | try: | |
| 48 | number= int(thisFile[4:10]) |
|
48 | number= int(thisFile[4:10]) | |
| 49 |
|
49 | |||
| 50 | # year = int(thisFile[1:5]) |
|
50 | # year = int(thisFile[1:5]) | |
| 51 | # doy = int(thisFile[5:8]) |
|
51 | # doy = int(thisFile[5:8]) | |
| 52 | except: |
|
52 | except: | |
| 53 | continue |
|
53 | continue | |
| 54 |
|
54 | |||
| 55 | if (os.path.splitext(thisFile)[-1].lower() != ext.lower()): |
|
55 | if (os.path.splitext(thisFile)[-1].lower() != ext.lower()): | |
| 56 | continue |
|
56 | continue | |
| 57 |
|
57 | |||
| 58 | validFilelist.append(thisFile) |
|
58 | validFilelist.append(thisFile) | |
| 59 | myfile = fnmatch.filter(validFilelist,'*%6.6d*'%(set)) |
|
59 | myfile = fnmatch.filter(validFilelist,'*%6.6d*'%(set)) | |
| 60 | #myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set)) |
|
60 | #myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set)) | |
| 61 |
|
61 | |||
| 62 | if len(myfile)!= 0: |
|
62 | if len(myfile)!= 0: | |
| 63 | return myfile[0] |
|
63 | return myfile[0] | |
| 64 | else: |
|
64 | else: | |
| 65 | filename = '*%6.6d%s'%(set,ext.lower()) |
|
65 | filename = '*%6.6d%s'%(set,ext.lower()) | |
| 66 | print 'the filename %s does not exist'%filename |
|
66 | print 'the filename %s does not exist'%filename | |
| 67 | print '...going to the last file: ' |
|
67 | print '...going to the last file: ' | |
| 68 |
|
68 | |||
| 69 | if validFilelist: |
|
69 | if validFilelist: | |
| 70 | validFilelist = sorted( validFilelist, key=str.lower ) |
|
70 | validFilelist = sorted( validFilelist, key=str.lower ) | |
| 71 | return validFilelist[-1] |
|
71 | return validFilelist[-1] | |
| 72 |
|
72 | |||
| 73 | return None |
|
73 | return None | |
| 74 |
|
74 | |||
| 75 | def getlastFileFromPath(path, ext): |
|
75 | def getlastFileFromPath(path, ext): | |
| 76 | """ |
|
76 | """ | |
| 77 | Depura el fileList dejando solo los que cumplan el formato de "res-xxxxxx.ext" |
|
77 | Depura el fileList dejando solo los que cumplan el formato de "res-xxxxxx.ext" | |
| 78 | al final de la depuracion devuelve el ultimo file de la lista que quedo. |
|
78 | al final de la depuracion devuelve el ultimo file de la lista que quedo. | |
| 79 |
|
79 | |||
| 80 | Input: |
|
80 | Input: | |
| 81 | fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta |
|
81 | fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta | |
| 82 | ext : extension de los files contenidos en una carpeta |
|
82 | ext : extension de los files contenidos en una carpeta | |
| 83 |
|
83 | |||
| 84 | Return: |
|
84 | Return: | |
| 85 | El ultimo file de una determinada carpeta, no se considera el path. |
|
85 | El ultimo file de una determinada carpeta, no se considera el path. | |
| 86 | """ |
|
86 | """ | |
| 87 | validFilelist = [] |
|
87 | validFilelist = [] | |
| 88 | fileList = os.listdir(path) |
|
88 | fileList = os.listdir(path) | |
| 89 |
|
89 | |||
| 90 | # 0 1234 567 89A BCDE |
|
90 | # 0 1234 567 89A BCDE | |
| 91 | # H YYYY DDD SSS .ext |
|
91 | # H YYYY DDD SSS .ext | |
| 92 |
|
92 | |||
| 93 | for thisFile in fileList: |
|
93 | for thisFile in fileList: | |
| 94 |
|
94 | |||
| 95 | try: |
|
95 | try: | |
| 96 | number= int(thisFile[4:10]) |
|
96 | number= int(thisFile[4:10]) | |
| 97 | except: |
|
97 | except: | |
| 98 | print "There is a file or folder with different format" |
|
98 | print "There is a file or folder with different format" | |
| 99 | if not isNumber(number): |
|
99 | if not isNumber(number): | |
| 100 | continue |
|
100 | continue | |
| 101 |
|
101 | |||
| 102 | # year = thisFile[1:5] |
|
102 | # year = thisFile[1:5] | |
| 103 | # if not isNumber(year): |
|
103 | # if not isNumber(year): | |
| 104 | # continue |
|
104 | # continue | |
| 105 |
|
105 | |||
| 106 | # doy = thisFile[5:8] |
|
106 | # doy = thisFile[5:8] | |
| 107 | # if not isNumber(doy): |
|
107 | # if not isNumber(doy): | |
| 108 | # continue |
|
108 | # continue | |
| 109 |
|
109 | |||
| 110 | number= int(number) |
|
110 | number= int(number) | |
| 111 | # year = int(year) |
|
111 | # year = int(year) | |
| 112 | # doy = int(doy) |
|
112 | # doy = int(doy) | |
| 113 |
|
113 | |||
| 114 | if (os.path.splitext(thisFile)[-1].lower() != ext.lower()): |
|
114 | if (os.path.splitext(thisFile)[-1].lower() != ext.lower()): | |
| 115 | continue |
|
115 | continue | |
| 116 |
|
116 | |||
| 117 |
|
117 | |||
| 118 | validFilelist.append(thisFile) |
|
118 | validFilelist.append(thisFile) | |
| 119 |
|
119 | |||
| 120 |
|
120 | |||
| 121 | if validFilelist: |
|
121 | if validFilelist: | |
| 122 | validFilelist = sorted( validFilelist, key=str.lower ) |
|
122 | validFilelist = sorted( validFilelist, key=str.lower ) | |
| 123 | return validFilelist[-1] |
|
123 | return validFilelist[-1] | |
| 124 |
|
124 | |||
| 125 | return None |
|
125 | return None | |
| 126 |
|
126 | |||
| 127 |
|
127 | |||
| 128 |
|
128 | |||
| 129 | class HFReader(ProcessingUnit): |
|
129 | class HFReader(ProcessingUnit): | |
| 130 | ''' |
|
130 | ''' | |
| 131 | classdocs |
|
131 | classdocs | |
| 132 | ''' |
|
132 | ''' | |
| 133 | path = None |
|
133 | path = None | |
| 134 | startDate= None |
|
134 | startDate= None | |
| 135 | endDate = None |
|
135 | endDate = None | |
| 136 | startTime= None |
|
136 | startTime= None | |
| 137 | endTime = None |
|
137 | endTime = None | |
| 138 | walk = None |
|
138 | walk = None | |
| 139 | isConfig = False |
|
139 | isConfig = False | |
| 140 | dataOut=None |
|
140 | dataOut=None | |
| 141 | nTries = 3 |
|
141 | nTries = 3 | |
| 142 | ext = ".hdf5" |
|
142 | ext = ".hdf5" | |
| 143 |
|
143 | |||
| 144 | def __init__(self): |
|
144 | def __init__(self): | |
| 145 | ''' |
|
145 | ''' | |
| 146 | Constructor |
|
146 | Constructor | |
| 147 | ''' |
|
147 | ''' | |
| 148 | ProcessingUnit.__init__(self) |
|
148 | ProcessingUnit.__init__(self) | |
| 149 |
|
149 | |||
| 150 | self.isConfig =False |
|
150 | self.isConfig =False | |
| 151 |
|
151 | |||
| 152 | self.datablock = None |
|
152 | self.datablock = None | |
| 153 |
|
153 | |||
| 154 | self.filename_current=None |
|
154 | self.filename_current=None | |
| 155 |
|
155 | |||
| 156 | self.utc = 0 |
|
156 | self.utc = 0 | |
| 157 |
|
157 | |||
| 158 | self.ext='.hdf5' |
|
158 | self.ext='.hdf5' | |
| 159 |
|
159 | |||
| 160 | self.flagIsNewFile = 1 |
|
160 | self.flagIsNewFile = 1 | |
| 161 |
|
161 | |||
| 162 | #------------------------------------------------- |
|
162 | #------------------------------------------------- | |
| 163 | self.fileIndex=None |
|
163 | self.fileIndex=None | |
| 164 |
|
164 | |||
| 165 | self.profileIndex_offset=None |
|
165 | self.profileIndex_offset=None | |
| 166 |
|
166 | |||
| 167 | self.filenameList=[] |
|
167 | self.filenameList=[] | |
| 168 |
|
168 | |||
| 169 | self.hfFilePointer= None |
|
169 | self.hfFilePointer= None | |
| 170 |
|
170 | |||
| 171 | self.filename_online = None |
|
171 | self.filename_online = None | |
| 172 |
|
172 | |||
| 173 | self.status=True |
|
173 | self.status=True | |
| 174 |
|
174 | |||
| 175 | self.flagNoMoreFiles= False |
|
175 | self.flagNoMoreFiles= False | |
| 176 |
|
176 | |||
| 177 | self.__waitForNewFile = 1 |
|
177 | self.__waitForNewFile = 1 | |
| 178 |
|
178 | |||
| 179 |
|
179 | |||
| 180 | #-------------------------------------------------- |
|
180 | #-------------------------------------------------- | |
| 181 |
|
181 | |||
| 182 | self.dataOut = self.createObjByDefault() |
|
182 | self.dataOut = self.createObjByDefault() | |
| 183 |
|
183 | |||
| 184 |
|
184 | |||
| 185 | def createObjByDefault(self): |
|
185 | def createObjByDefault(self): | |
| 186 |
|
186 | |||
| 187 | dataObj = Voltage() |
|
187 | dataObj = Voltage() | |
| 188 |
|
188 | |||
| 189 | return dataObj |
|
189 | return dataObj | |
| 190 |
|
190 | |||
| 191 | def setObjProperties(self): |
|
191 | def setObjProperties(self): | |
| 192 |
|
192 | |||
| 193 | pass |
|
193 | pass | |
| 194 |
|
194 | |||
| 195 | def getBlockDimension(self): |
|
195 | def getBlockDimension(self): | |
| 196 | """ |
|
196 | """ | |
| 197 | Obtiene la cantidad de puntos a leer por cada bloque de datos |
|
197 | Obtiene la cantidad de puntos a leer por cada bloque de datos | |
| 198 |
|
198 | |||
| 199 | Affected: |
|
199 | Affected: | |
| 200 | self.blocksize |
|
200 | self.blocksize | |
| 201 |
|
201 | |||
| 202 | Return: |
|
202 | Return: | |
| 203 | None |
|
203 | None | |
| 204 | """ |
|
204 | """ | |
| 205 | pts2read =self.nChannels*self.nHeights*self.nProfiles |
|
205 | pts2read =self.nChannels*self.nHeights*self.nProfiles | |
| 206 | self.blocksize = pts2read |
|
206 | self.blocksize = pts2read | |
| 207 |
|
207 | |||
| 208 | def __readHeader(self): |
|
208 | def __readHeader(self): | |
| 209 |
|
209 | |||
| 210 | self.nProfiles = 100 |
|
210 | self.nProfiles = 100 | |
| 211 | self.nHeights = 1000 |
|
211 | self.nHeights = 1000 | |
| 212 | self.nChannels = 2 |
|
212 | self.nChannels = 2 | |
| 213 | self.__firstHeigth=0 |
|
213 | self.__firstHeigth=0 | |
| 214 | self.__nSamples=1000 |
|
214 | self.__nSamples=1000 | |
| 215 | self.__deltaHeigth=1.5 |
|
215 | self.__deltaHeigth=1.5 | |
| 216 | self.__sample_rate=1e5 |
|
216 | self.__sample_rate=1e5 | |
| 217 | #self.__frequency=2.72e6 |
|
217 | #self.__frequency=2.72e6 | |
| 218 | #self.__frequency=3.64e6 |
|
218 | #self.__frequency=3.64e6 | |
| 219 | self.__frequency=None |
|
219 | self.__frequency=None | |
| 220 | self.__online = False |
|
220 | self.__online = False | |
| 221 | self.filename_next_set=None |
|
221 | self.filename_next_set=None | |
| 222 |
|
222 | |||
| 223 | #print "Frequency of Operation:", self.__frequency |
|
223 | #print "Frequency of Operation:", self.__frequency | |
| 224 |
|
224 | |||
| 225 |
|
225 | |||
| 226 | def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''): |
|
226 | def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''): | |
| 227 | self.path = path |
|
227 | self.path = path | |
| 228 | self.startDate = startDate |
|
228 | self.startDate = startDate | |
| 229 | self.endDate = endDate |
|
229 | self.endDate = endDate | |
| 230 | self.startTime = startTime |
|
230 | self.startTime = startTime | |
| 231 | self.endTime = endTime |
|
231 | self.endTime = endTime | |
| 232 | self.walk = walk |
|
232 | self.walk = walk | |
| 233 |
|
233 | |||
| 234 | def __checkPath(self): |
|
234 | def __checkPath(self): | |
| 235 | if os.path.exists(self.path): |
|
235 | if os.path.exists(self.path): | |
| 236 | self.status=1 |
|
236 | self.status=1 | |
| 237 | else: |
|
237 | else: | |
| 238 | self.status=0 |
|
238 | self.status=0 | |
| 239 | print 'Path %s does not exits'%self.path |
|
239 | print 'Path %s does not exits'%self.path | |
| 240 | return |
|
240 | return | |
| 241 | return |
|
241 | return | |
| 242 |
|
242 | |||
| 243 | def __selDates(self, hf_dirname_format): |
|
243 | def __selDates(self, hf_dirname_format): | |
| 244 | try: |
|
244 | try: | |
| 245 | dir_hf_filename= self.path+"/"+hf_dirname_format |
|
245 | dir_hf_filename= self.path+"/"+hf_dirname_format | |
| 246 | fp= h5py.File(dir_hf_filename,'r') |
|
246 | fp= h5py.File(dir_hf_filename,'r') | |
| 247 | hipoc=fp['t'].value |
|
247 | hipoc=fp['t'].value | |
| 248 | fp.close() |
|
248 | fp.close() | |
| 249 | date_time=stuffr.unix2datestr(hipoc) |
|
249 | date_time=stuffr.unix2datestr(hipoc) | |
| 250 | year =int(date_time[0:4]) |
|
250 | year =int(date_time[0:4]) | |
| 251 | month=int(date_time[5:7]) |
|
251 | month=int(date_time[5:7]) | |
| 252 | dom =int(date_time[8:10]) |
|
252 | dom =int(date_time[8:10]) | |
| 253 | thisDate= datetime.date(year,month,dom) |
|
253 | thisDate= datetime.date(year,month,dom) | |
| 254 | if (thisDate>=self.startDate and thisDate <= self.endDate): |
|
254 | if (thisDate>=self.startDate and thisDate <= self.endDate): | |
| 255 | return hf_dirname_format |
|
255 | return hf_dirname_format | |
| 256 | except: |
|
256 | except: | |
| 257 | return None |
|
257 | return None | |
| 258 |
|
258 | |||
| 259 | def __findDataForDates(self,online=False): |
|
259 | def __findDataForDates(self,online=False): | |
| 260 | if not(self.status): |
|
260 | if not(self.status): | |
| 261 | return None |
|
261 | return None | |
| 262 |
|
262 | |||
| 263 | pat = '\d+.\d+' |
|
263 | pat = '\d+.\d+' | |
| 264 | dirnameList = [re.search(pat,x) for x in os.listdir(self.path)] |
|
264 | dirnameList = [re.search(pat,x) for x in os.listdir(self.path)] | |
| 265 | dirnameList = filter(lambda x:x!=None,dirnameList) |
|
265 | dirnameList = filter(lambda x:x!=None,dirnameList) | |
| 266 | dirnameList = [x.string for x in dirnameList] |
|
266 | dirnameList = [x.string for x in dirnameList] | |
| 267 | if not(online): |
|
267 | if not(online): | |
| 268 |
|
268 | |||
| 269 | dirnameList = [self.__selDates(x) for x in dirnameList] |
|
269 | dirnameList = [self.__selDates(x) for x in dirnameList] | |
| 270 | dirnameList = filter(lambda x:x!=None,dirnameList) |
|
270 | dirnameList = filter(lambda x:x!=None,dirnameList) | |
| 271 |
|
271 | |||
| 272 | if len(dirnameList)>0: |
|
272 | if len(dirnameList)>0: | |
| 273 | self.status = 1 |
|
273 | self.status = 1 | |
| 274 | self.dirnameList = dirnameList |
|
274 | self.dirnameList = dirnameList | |
| 275 | self.dirnameList.sort() |
|
275 | self.dirnameList.sort() | |
| 276 |
|
276 | |||
| 277 | else: |
|
277 | else: | |
| 278 | self.status = 0 |
|
278 | self.status = 0 | |
| 279 | return None |
|
279 | return None | |
| 280 |
|
280 | |||
| 281 | def __getTimeFromData(self): |
|
281 | def __getTimeFromData(self): | |
| 282 | startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime) |
|
282 | startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime) | |
| 283 | endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime) |
|
283 | endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime) | |
| 284 | print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader) |
|
284 | print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader) | |
| 285 | print '........................................' |
|
285 | print '........................................' | |
| 286 | filter_filenameList=[] |
|
286 | filter_filenameList=[] | |
| 287 | self.filenameList.sort() |
|
287 | self.filenameList.sort() | |
| 288 | for i in range(len(self.filenameList)-1): |
|
288 | for i in range(len(self.filenameList)-1): | |
| 289 | filename=self.filenameList[i] |
|
289 | filename=self.filenameList[i] | |
| 290 | dir_hf_filename= filename |
|
290 | dir_hf_filename= filename | |
| 291 | fp= h5py.File(dir_hf_filename,'r') |
|
291 | fp= h5py.File(dir_hf_filename,'r') | |
| 292 | hipoc=fp['t'].value |
|
292 | hipoc=fp['t'].value | |
| 293 | hipoc=hipoc+self.timezone |
|
293 | hipoc=hipoc+self.timezone | |
| 294 | date_time=stuffr.unix2datestr(hipoc) |
|
294 | date_time=stuffr.unix2datestr(hipoc) | |
| 295 | fp.close() |
|
295 | fp.close() | |
| 296 | year =int(date_time[0:4]) |
|
296 | year =int(date_time[0:4]) | |
| 297 | month=int(date_time[5:7]) |
|
297 | month=int(date_time[5:7]) | |
| 298 | dom =int(date_time[8:10]) |
|
298 | dom =int(date_time[8:10]) | |
| 299 | hour =int(date_time[11:13]) |
|
299 | hour =int(date_time[11:13]) | |
| 300 | min =int(date_time[14:16]) |
|
300 | min =int(date_time[14:16]) | |
| 301 | sec =int(date_time[17:19]) |
|
301 | sec =int(date_time[17:19]) | |
| 302 | this_time=datetime.datetime(year,month,dom,hour,min,sec) |
|
302 | this_time=datetime.datetime(year,month,dom,hour,min,sec) | |
| 303 | if (this_time>=startDateTime_Reader and this_time <= endDateTime_Reader): |
|
303 | if (this_time>=startDateTime_Reader and this_time <= endDateTime_Reader): | |
| 304 | filter_filenameList.append(filename) |
|
304 | filter_filenameList.append(filename) | |
| 305 | filter_filenameList.sort() |
|
305 | filter_filenameList.sort() | |
| 306 | self.filenameList = filter_filenameList |
|
306 | self.filenameList = filter_filenameList | |
| 307 | return 1 |
|
307 | return 1 | |
| 308 |
|
308 | |||
| 309 | def __getFilenameList(self): |
|
309 | def __getFilenameList(self): | |
| 310 | #print "hola" |
|
310 | #print "hola" | |
| 311 | #print self.dirnameList |
|
311 | #print self.dirnameList | |
| 312 | dirList = [os.path.join(self.path,x) for x in self.dirnameList] |
|
312 | dirList = [os.path.join(self.path,x) for x in self.dirnameList] | |
| 313 | self.filenameList= dirList |
|
313 | self.filenameList= dirList | |
| 314 | #print self.filenameList |
|
314 | #print self.filenameList | |
| 315 | #print "pase",len(self.filenameList) |
|
315 | #print "pase",len(self.filenameList) | |
| 316 |
|
316 | |||
| 317 | def __selectDataForTimes(self, online=False): |
|
317 | def __selectDataForTimes(self, online=False): | |
| 318 |
|
318 | |||
| 319 | if not(self.status): |
|
319 | if not(self.status): | |
| 320 | return None |
|
320 | return None | |
| 321 | #---------------- |
|
321 | #---------------- | |
| 322 | self.__getFilenameList() |
|
322 | self.__getFilenameList() | |
| 323 | #---------------- |
|
323 | #---------------- | |
| 324 | if not(online): |
|
324 | if not(online): | |
| 325 | if not(self.all): |
|
325 | if not(self.all): | |
| 326 | self.__getTimeFromData() |
|
326 | self.__getTimeFromData() | |
| 327 | if len(self.filenameList)>0: |
|
327 | if len(self.filenameList)>0: | |
| 328 | self.status=1 |
|
328 | self.status=1 | |
| 329 | self.filenameList.sort() |
|
329 | self.filenameList.sort() | |
| 330 | else: |
|
330 | else: | |
| 331 | self.status=0 |
|
331 | self.status=0 | |
| 332 | return None |
|
332 | return None | |
| 333 | else: |
|
333 | else: | |
| 334 | if self.set== None: |
|
334 | if self.set== None: | |
| 335 | filename =getlastFileFromPath(self.path,self.ext) |
|
335 | filename =getlastFileFromPath(self.path,self.ext) | |
| 336 |
|
336 | |||
| 337 | if self.flag_nextfile==True: |
|
337 | if self.flag_nextfile==True: | |
| 338 | self.dirnameList=[filename] |
|
338 | self.dirnameList=[filename] | |
| 339 | fullfilename=self.path+"/"+filename |
|
339 | fullfilename=self.path+"/"+filename | |
| 340 | self.filenameList=[self.filenameList[-1]] |
|
340 | self.filenameList=[self.filenameList[-1]] | |
| 341 | self.filename_next_set=int(filename[4:10])+1 |
|
341 | self.filename_next_set=int(filename[4:10])+1 | |
| 342 |
|
342 | |||
| 343 | self.flag_nextfile=False |
|
343 | self.flag_nextfile=False | |
| 344 | else: |
|
344 | else: | |
| 345 | if self.filename_next_set== int(filename[4:10]): |
|
345 | if self.filename_next_set== int(filename[4:10]): | |
| 346 | self.dirnameList=[filename] |
|
346 | self.dirnameList=[filename] | |
| 347 | fullfilename=self.path+"/"+filename |
|
347 | fullfilename=self.path+"/"+filename | |
| 348 | self.filenameList=[self.filenameList[-1]] |
|
348 | self.filenameList=[self.filenameList[-1]] | |
| 349 | self.filename_next_set=int(filename[4:10])+1 |
|
349 | self.filename_next_set=int(filename[4:10])+1 | |
| 350 |
|
350 | |||
| 351 | else: |
|
351 | else: | |
| 352 | set=self.filename_next_set |
|
352 | set=self.filename_next_set | |
| 353 | filename=getFileFromSet(self.path,self.ext,set=set) |
|
353 | filename=getFileFromSet(self.path,self.ext,set=set) | |
| 354 | self.filename_next_set=int(filename[4:10])+1 |
|
354 | self.filename_next_set=int(filename[4:10])+1 | |
| 355 | if filename==None: |
|
355 | if filename==None: | |
| 356 | filename =getlastFileFromPath(self.path,self.ext) |
|
356 | filename =getlastFileFromPath(self.path,self.ext) | |
| 357 | self.filename_next_set=int(filename[4:10]) |
|
357 | self.filename_next_set=int(filename[4:10]) | |
| 358 | self.dirnameList=[filename] |
|
358 | self.dirnameList=[filename] | |
| 359 | fullfilename=self.path+"/"+filename |
|
359 | fullfilename=self.path+"/"+filename | |
| 360 | self.filenameList=[self.filenameList[-1]] |
|
360 | self.filenameList=[self.filenameList[-1]] | |
| 361 |
|
361 | |||
| 362 | else: |
|
362 | else: | |
| 363 | try: |
|
363 | try: | |
| 364 | filename=getFileFromSet(self.path,self.ext,self.set) |
|
364 | filename=getFileFromSet(self.path,self.ext,self.set) | |
| 365 | self.dirnameList=[filename] |
|
365 | self.dirnameList=[filename] | |
| 366 | fullfilename=self.path+"/"+filename |
|
366 | fullfilename=self.path+"/"+filename | |
| 367 | self.filenameList=[fullfilename] |
|
367 | self.filenameList=[fullfilename] | |
| 368 | except: |
|
368 | except: | |
| 369 | self.filenameList=[self.filenameList[-1]] |
|
369 | self.filenameList=[self.filenameList[-1]] | |
| 370 |
|
370 | |||
| 371 |
|
371 | |||
| 372 | def __searchFilesOffline(self, |
|
372 | def __searchFilesOffline(self, | |
| 373 | path, |
|
373 | path, | |
| 374 | startDate, |
|
374 | startDate, | |
| 375 | endDate, |
|
375 | endDate, | |
| 376 | ext, |
|
376 | ext, | |
| 377 | startTime=datetime.time(0,0,0), |
|
377 | startTime=datetime.time(0,0,0), | |
| 378 | endTime=datetime.time(23,59,59), |
|
378 | endTime=datetime.time(23,59,59), | |
| 379 | walk=True): |
|
379 | walk=True): | |
| 380 |
|
380 | |||
| 381 | self.__setParameters(path, startDate, endDate, startTime, endTime, walk) |
|
381 | self.__setParameters(path, startDate, endDate, startTime, endTime, walk) | |
| 382 |
|
382 | |||
| 383 | self.__checkPath() |
|
383 | self.__checkPath() | |
| 384 |
|
384 | |||
| 385 | self.__findDataForDates() |
|
385 | self.__findDataForDates() | |
| 386 | #print self.dirnameList |
|
386 | #print self.dirnameList | |
| 387 |
|
387 | |||
| 388 | self.__selectDataForTimes() |
|
388 | self.__selectDataForTimes() | |
| 389 |
|
389 | |||
| 390 | for i in range(len(self.filenameList)): |
|
390 | for i in range(len(self.filenameList)): | |
| 391 | print "%s"% (self.filenameList[i]) |
|
391 | print "%s"% (self.filenameList[i]) | |
| 392 |
|
392 | |||
| 393 | return |
|
393 | return | |
| 394 |
|
394 | |||
| 395 | def __searchFilesOnline(self, |
|
395 | def __searchFilesOnline(self, | |
| 396 | path, |
|
396 | path, | |
| 397 | expLabel= "", |
|
397 | expLabel= "", | |
| 398 | ext=None, |
|
398 | ext=None, | |
| 399 | startDate=None, |
|
399 | startDate=None, | |
| 400 | endDate=None, |
|
400 | endDate=None, | |
| 401 | walk=True, |
|
401 | walk=True, | |
| 402 | set=None): |
|
402 | set=None): | |
| 403 |
|
403 | |||
| 404 |
|
404 | |||
| 405 | startDate = datetime.datetime.utcnow().date() |
|
405 | startDate = datetime.datetime.utcnow().date() | |
| 406 | endDate = datetime.datetime.utcnow().date() |
|
406 | endDate = datetime.datetime.utcnow().date() | |
| 407 |
|
407 | |||
| 408 | self.__setParameters(path=path,startDate=startDate,endDate=endDate,walk=walk) |
|
408 | self.__setParameters(path=path,startDate=startDate,endDate=endDate,walk=walk) | |
| 409 |
|
409 | |||
| 410 | self.__checkPath() |
|
410 | self.__checkPath() | |
| 411 |
|
411 | |||
| 412 | fullpath=path |
|
412 | fullpath=path | |
| 413 | print "%s folder was found: " %(fullpath ) |
|
413 | print "%s folder was found: " %(fullpath ) | |
| 414 |
|
414 | |||
| 415 | if set == None: |
|
415 | if set == None: | |
| 416 | self.set=None |
|
416 | self.set=None | |
| 417 | filename =getlastFileFromPath(fullpath,ext) |
|
417 | filename =getlastFileFromPath(fullpath,ext) | |
| 418 | startDate= datetime.datetime.utcnow().date |
|
418 | startDate= datetime.datetime.utcnow().date | |
| 419 | endDate= datetime.datetime.utcnow().date() |
|
419 | endDate= datetime.datetime.utcnow().date() | |
| 420 | # |
|
420 | # | |
| 421 | else: |
|
421 | else: | |
| 422 | filename= getFileFromSet(fullpath,ext,set) |
|
422 | filename= getFileFromSet(fullpath,ext,set) | |
| 423 | startDate=None |
|
423 | startDate=None | |
| 424 | endDate=None |
|
424 | endDate=None | |
| 425 | # |
|
425 | # | |
| 426 | if not (filename): |
|
426 | if not (filename): | |
| 427 | return None,None,None,None,None |
|
427 | return None,None,None,None,None | |
| 428 | #print "%s file was found" %(filename) |
|
428 | #print "%s file was found" %(filename) | |
| 429 |
|
429 | |||
| 430 | # |
|
430 | # | |
| 431 | # dir_hf_filename= self.path+"/"+filename |
|
431 | # dir_hf_filename= self.path+"/"+filename | |
| 432 | # fp= h5py.File(dir_hf_filename,'r') |
|
432 | # fp= h5py.File(dir_hf_filename,'r') | |
| 433 | # hipoc=fp['t'].value |
|
433 | # hipoc=fp['t'].value | |
| 434 | # fp.close() |
|
434 | # fp.close() | |
| 435 | # date_time=stuffr.unix2datestr(hipoc) |
|
435 | # date_time=stuffr.unix2datestr(hipoc) | |
| 436 | # |
|
436 | # | |
| 437 | # year =int(date_time[0:4]) |
|
437 | # year =int(date_time[0:4]) | |
| 438 | # month=int(date_time[5:7]) |
|
438 | # month=int(date_time[5:7]) | |
| 439 | # dom =int(date_time[8:10]) |
|
439 | # dom =int(date_time[8:10]) | |
| 440 | # set= int(filename[4:10]) |
|
440 | # set= int(filename[4:10]) | |
| 441 | # self.set=set-1 |
|
441 | # self.set=set-1 | |
| 442 | #self.dirnameList=[filename] |
|
442 | #self.dirnameList=[filename] | |
| 443 | filenameList= fullpath+"/"+filename |
|
443 | filenameList= fullpath+"/"+filename | |
| 444 | self.dirnameList=[filename] |
|
444 | self.dirnameList=[filename] | |
| 445 | self.filenameList=[filenameList] |
|
445 | self.filenameList=[filenameList] | |
| 446 | self.flag_nextfile=True |
|
446 | self.flag_nextfile=True | |
| 447 |
|
447 | |||
| 448 | #self.__findDataForDates(online=True) |
|
448 | #self.__findDataForDates(online=True) | |
| 449 | #self.dirnameList=[self.dirnameList[-1]] |
|
449 | #self.dirnameList=[self.dirnameList[-1]] | |
| 450 | #print self.dirnameList |
|
450 | #print self.dirnameList | |
| 451 | #self.__selectDataForTimes(online=True) |
|
451 | #self.__selectDataForTimes(online=True) | |
| 452 | #return fullpath,filename,year,month,dom,set |
|
452 | #return fullpath,filename,year,month,dom,set | |
| 453 | return |
|
453 | return | |
| 454 |
|
454 | |||
| 455 | def __setNextFile(self,online=False): |
|
455 | def __setNextFile(self,online=False): | |
| 456 | """ |
|
456 | """ | |
| 457 | """ |
|
457 | """ | |
| 458 | if not(online): |
|
458 | if not(online): | |
| 459 | newFile = self.__setNextFileOffline() |
|
459 | newFile = self.__setNextFileOffline() | |
| 460 | else: |
|
460 | else: | |
| 461 | newFile = self.__setNextFileOnline() |
|
461 | newFile = self.__setNextFileOnline() | |
| 462 |
|
462 | |||
| 463 | if not(newFile): |
|
463 | if not(newFile): | |
| 464 | return 0 |
|
464 | return 0 | |
| 465 | return 1 |
|
465 | return 1 | |
| 466 |
|
466 | |||
| 467 | def __setNextFileOffline(self): |
|
467 | def __setNextFileOffline(self): | |
| 468 | """ |
|
468 | """ | |
| 469 | """ |
|
469 | """ | |
| 470 | idFile= self.fileIndex |
|
470 | idFile= self.fileIndex | |
| 471 | while(True): |
|
471 | while(True): | |
| 472 | idFile += 1 |
|
472 | idFile += 1 | |
| 473 | if not (idFile < len(self.filenameList)): |
|
473 | if not (idFile < len(self.filenameList)): | |
| 474 | self.flagNoMoreFiles = 1 |
|
474 | self.flagNoMoreFiles = 1 | |
| 475 | print "No more Files" |
|
475 | print "No more Files" | |
| 476 | return 0 |
|
476 | return 0 | |
| 477 | filename = self.filenameList[idFile] |
|
477 | filename = self.filenameList[idFile] | |
| 478 | hfFilePointer =h5py.File(filename,'r') |
|
478 | hfFilePointer =h5py.File(filename,'r') | |
| 479 |
|
479 | |||
| 480 | epoc=hfFilePointer['t'].value |
|
480 | epoc=hfFilePointer['t'].value | |
| 481 | #this_time=datetime.datetime(year,month,dom,hour,min,sec) |
|
481 | #this_time=datetime.datetime(year,month,dom,hour,min,sec) | |
| 482 | break |
|
482 | break | |
| 483 |
|
483 | |||
| 484 | self.flagIsNewFile = 1 |
|
484 | self.flagIsNewFile = 1 | |
| 485 | self.fileIndex = idFile |
|
485 | self.fileIndex = idFile | |
| 486 | self.filename = filename |
|
486 | self.filename = filename | |
| 487 |
|
487 | |||
| 488 | self.hfFilePointer = hfFilePointer |
|
488 | self.hfFilePointer = hfFilePointer | |
| 489 | hfFilePointer.close() |
|
489 | hfFilePointer.close() | |
| 490 | self.__t0=epoc |
|
490 | self.__t0=epoc | |
| 491 | print "Setting the file: %s"%self.filename |
|
491 | print "Setting the file: %s"%self.filename | |
| 492 |
|
492 | |||
| 493 | return 1 |
|
493 | return 1 | |
| 494 |
|
494 | |||
| 495 | def __setNextFileOnline(self): |
|
495 | def __setNextFileOnline(self): | |
| 496 | """ |
|
496 | """ | |
| 497 | """ |
|
497 | """ | |
| 498 | if self.set==None: |
|
498 | if self.set==None: | |
| 499 | pass |
|
499 | pass | |
| 500 | else: |
|
500 | else: | |
| 501 | self.set +=1 |
|
501 | self.set +=1 | |
| 502 |
|
502 | |||
| 503 | filename = self.filenameList[0]#fullfilename |
|
503 | filename = self.filenameList[0]#fullfilename | |
| 504 | if self.filename_online != None: |
|
504 | if self.filename_online != None: | |
| 505 | self.__selectDataForTimes(online=True) |
|
505 | self.__selectDataForTimes(online=True) | |
| 506 | filename = self.filenameList[0] |
|
506 | filename = self.filenameList[0] | |
| 507 | while self.filename_online == filename: |
|
507 | while self.filename_online == filename: | |
| 508 | print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile) |
|
508 | print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile) | |
| 509 | time.sleep(self.__waitForNewFile) |
|
509 | time.sleep(self.__waitForNewFile) | |
| 510 | #self.__findDataForDates(online=True) |
|
510 | #self.__findDataForDates(online=True) | |
| 511 | self.__selectDataForTimes(online=True) |
|
511 | self.__selectDataForTimes(online=True) | |
| 512 | filename = self.filenameList[0] |
|
512 | filename = self.filenameList[0] | |
| 513 | sizeoffile=os.path.getsize(filename) |
|
513 | sizeoffile=os.path.getsize(filename) | |
| 514 |
|
514 | |||
| 515 | #print filename |
|
515 | #print filename | |
| 516 | sizeoffile=os.path.getsize(filename) |
|
516 | sizeoffile=os.path.getsize(filename) | |
| 517 | if sizeoffile<1650240: |
|
517 | if sizeoffile<1650240: | |
| 518 | print "%s is not the rigth size"%filename |
|
518 | print "%s is not the rigth size"%filename | |
| 519 | delay=2 |
|
519 | delay=2 | |
| 520 | print 'waiting %d seconds for delay...'%(delay) |
|
520 | print 'waiting %d seconds for delay...'%(delay) | |
| 521 | time.sleep(delay) |
|
521 | time.sleep(delay) | |
| 522 | sizeoffile=os.path.getsize(filename) |
|
522 | sizeoffile=os.path.getsize(filename) | |
| 523 | if sizeoffile<1650240: |
|
523 | if sizeoffile<1650240: | |
| 524 | delay |
|
524 | delay | |
| 525 | print 'waiting %d more seconds for delay...'%(delay) |
|
525 | print 'waiting %d more seconds for delay...'%(delay) | |
| 526 | time.sleep(delay) |
|
526 | time.sleep(delay) | |
| 527 |
|
527 | |||
| 528 |
|
528 | |||
| 529 |
|
529 | |||
| 530 | try: |
|
530 | try: | |
| 531 | hfFilePointer=h5py.File(filename,'r') |
|
531 | hfFilePointer=h5py.File(filename,'r') | |
| 532 |
|
532 | |||
| 533 | except: |
|
533 | except: | |
| 534 | print "Error reading file %s"%filename |
|
534 | print "Error reading file %s"%filename | |
| 535 |
|
535 | |||
| 536 | self.filename_online=filename |
|
536 | self.filename_online=filename | |
| 537 | epoc=hfFilePointer['t'].value |
|
537 | epoc=hfFilePointer['t'].value | |
| 538 |
|
538 | |||
| 539 | self.hfFilePointer=hfFilePointer |
|
539 | self.hfFilePointer=hfFilePointer | |
| 540 | hfFilePointer.close() |
|
540 | hfFilePointer.close() | |
| 541 | self.__t0=epoc |
|
541 | self.__t0=epoc | |
| 542 |
|
542 | |||
| 543 |
|
543 | |||
| 544 | self.flagIsNewFile = 1 |
|
544 | self.flagIsNewFile = 1 | |
| 545 | self.filename = filename |
|
545 | self.filename = filename | |
| 546 |
|
546 | |||
| 547 | print "Setting the file: %s"%self.filename |
|
547 | print "Setting the file: %s"%self.filename | |
| 548 | return 1 |
|
548 | return 1 | |
| 549 |
|
549 | |||
| 550 | def __getExpParameters(self): |
|
550 | def __getExpParameters(self): | |
| 551 | if not(self.status): |
|
551 | if not(self.status): | |
| 552 | return None |
|
552 | return None | |
| 553 |
|
553 | |||
| 554 | def setup(self, |
|
554 | def setup(self, | |
| 555 | path = None, |
|
555 | path = None, | |
| 556 | startDate = None, |
|
556 | startDate = None, | |
| 557 | endDate = None, |
|
557 | endDate = None, | |
| 558 | startTime = datetime.time(0,0,0), |
|
558 | startTime = datetime.time(0,0,0), | |
| 559 | endTime = datetime.time(23,59,59), |
|
559 | endTime = datetime.time(23,59,59), | |
| 560 | set = None, |
|
560 | set = None, | |
| 561 | expLabel = "", |
|
561 | expLabel = "", | |
| 562 | ext = None, |
|
562 | ext = None, | |
| 563 | all=0, |
|
563 | all=0, | |
| 564 | timezone=0, |
|
564 | timezone=0, | |
| 565 | online = False, |
|
565 | online = False, | |
| 566 | delay = 60, |
|
566 | delay = 60, | |
| 567 | walk = True): |
|
567 | walk = True): | |
| 568 | ''' |
|
568 | ''' | |
| 569 | In this method we should set all initial parameters. |
|
569 | In this method we should set all initial parameters. | |
| 570 |
|
570 | |||
| 571 | ''' |
|
571 | ''' | |
| 572 | if path==None: |
|
572 | if path==None: | |
| 573 | raise ValueError,"The path is not valid" |
|
573 | raise ValueError,"The path is not valid" | |
| 574 |
|
574 | |||
| 575 | if ext==None: |
|
575 | if ext==None: | |
| 576 | ext = self.ext |
|
576 | ext = self.ext | |
| 577 |
|
577 | |||
| 578 | self.timezone= timezone |
|
578 | self.timezone= timezone | |
| 579 | self.online= online |
|
579 | self.online= online | |
| 580 | self.all=all |
|
580 | self.all=all | |
| 581 | #if set==None: |
|
581 | #if set==None: | |
| 582 |
|
582 | |||
| 583 | #print set |
|
583 | #print set | |
| 584 | if not(online): |
|
584 | if not(online): | |
| 585 | print "Searching files in offline mode..." |
|
585 | print "Searching files in offline mode..." | |
| 586 |
|
586 | |||
| 587 | self.__searchFilesOffline(path, startDate, endDate, ext, startTime, endTime, walk) |
|
587 | self.__searchFilesOffline(path, startDate, endDate, ext, startTime, endTime, walk) | |
| 588 | else: |
|
588 | else: | |
| 589 | print "Searching files in online mode..." |
|
589 | print "Searching files in online mode..." | |
| 590 | self.__searchFilesOnline(path, walk,ext,set=set) |
|
590 | self.__searchFilesOnline(path, walk,ext,set=set) | |
| 591 | if set==None: |
|
591 | if set==None: | |
| 592 | pass |
|
592 | pass | |
| 593 | else: |
|
593 | else: | |
| 594 | self.set=set-1 |
|
594 | self.set=set-1 | |
| 595 |
|
595 | |||
| 596 | # for nTries in range(self.nTries): |
|
596 | # for nTries in range(self.nTries): | |
| 597 | # |
|
597 | # | |
| 598 | # fullpath,file,year,month,day,set = self.__searchFilesOnline(path=path,expLabel=expLabel,ext=ext, walk=walk,set=set) |
|
598 | # fullpath,file,year,month,day,set = self.__searchFilesOnline(path=path,expLabel=expLabel,ext=ext, walk=walk,set=set) | |
| 599 | # |
|
599 | # | |
| 600 | # if fullpath: |
|
600 | # if fullpath: | |
| 601 | # break |
|
601 | # break | |
| 602 | # print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1) |
|
602 | # print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1) | |
| 603 | # time.sleep(self.delay) |
|
603 | # time.sleep(self.delay) | |
| 604 | # if not(fullpath): |
|
604 | # if not(fullpath): | |
| 605 | # print "There ins't valid files in %s" % path |
|
605 | # print "There ins't valid files in %s" % path | |
| 606 | # return None |
|
606 | # return None | |
| 607 |
|
607 | |||
| 608 |
|
608 | |||
| 609 | if not(self.filenameList): |
|
609 | if not(self.filenameList): | |
| 610 | print "There is no files into the folder: %s"%(path) |
|
610 | print "There is no files into the folder: %s"%(path) | |
| 611 | sys.exit(-1) |
|
611 | sys.exit(-1) | |
| 612 |
|
612 | |||
| 613 | self.__getExpParameters() |
|
613 | self.__getExpParameters() | |
| 614 |
|
614 | |||
| 615 |
|
615 | |||
| 616 | self.fileIndex = -1 |
|
616 | self.fileIndex = -1 | |
| 617 |
|
617 | |||
| 618 | self.__setNextFile(online) |
|
618 | self.__setNextFile(online) | |
| 619 |
|
619 | |||
| 620 | self.__readMetadata() |
|
620 | self.__readMetadata() | |
| 621 |
|
621 | |||
| 622 | self.__setLocalVariables() |
|
622 | self.__setLocalVariables() | |
| 623 |
|
623 | |||
| 624 | self.__setHeaderDO() |
|
624 | self.__setHeaderDO() | |
| 625 | #self.profileIndex_offset= 0 |
|
625 | #self.profileIndex_offset= 0 | |
| 626 |
|
626 | |||
| 627 | #self.profileIndex = self.profileIndex_offset |
|
627 | #self.profileIndex = self.profileIndex_offset | |
| 628 |
|
628 | |||
| 629 | self.isConfig = True |
|
629 | self.isConfig = True | |
| 630 |
|
630 | |||
| 631 | def __readMetadata(self): |
|
631 | def __readMetadata(self): | |
| 632 | self.__readHeader() |
|
632 | self.__readHeader() | |
| 633 |
|
633 | |||
| 634 |
|
634 | |||
| 635 | def __setLocalVariables(self): |
|
635 | def __setLocalVariables(self): | |
| 636 |
|
636 | |||
| 637 | self.datablock = numpy.zeros((self.nChannels, self.nHeights,self.nProfiles), dtype = numpy.complex) |
|
637 | self.datablock = numpy.zeros((self.nChannels, self.nHeights,self.nProfiles), dtype = numpy.complex) | |
| 638 | # |
|
638 | # | |
| 639 |
|
639 | |||
| 640 |
|
640 | |||
| 641 |
|
641 | |||
| 642 | self.profileIndex = 9999 |
|
642 | self.profileIndex = 9999 | |
| 643 |
|
643 | |||
| 644 |
|
644 | |||
| 645 | def __setHeaderDO(self): |
|
645 | def __setHeaderDO(self): | |
| 646 |
|
646 | |||
| 647 |
|
647 | |||
| 648 | self.dataOut.radarControllerHeaderObj = RadarControllerHeader() |
|
648 | self.dataOut.radarControllerHeaderObj = RadarControllerHeader() | |
| 649 |
|
649 | |||
| 650 | self.dataOut.systemHeaderObj = SystemHeader() |
|
650 | self.dataOut.systemHeaderObj = SystemHeader() | |
| 651 |
|
651 | |||
|
|
652 | ||||
|
|
653 | #--------------------------------------------------------- | |||
|
|
654 | self.dataOut.systemHeaderObj.nProfiles=100 | |||
|
|
655 | self.dataOut.systemHeaderObj.nSamples=1000 | |||
|
|
656 | ||||
|
|
657 | ||||
|
|
658 | SAMPLING_STRUCTURE=[('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')] | |||
|
|
659 | self.dataOut.radarControllerHeaderObj.samplingWindow=numpy.zeros((1,),SAMPLING_STRUCTURE) | |||
|
|
660 | self.dataOut.radarControllerHeaderObj.samplingWindow['h0']=0 | |||
|
|
661 | self.dataOut.radarControllerHeaderObj.samplingWindow['dh']=1.5 | |||
|
|
662 | self.dataOut.radarControllerHeaderObj.samplingWindow['nsa']=1000 | |||
|
|
663 | self.dataOut.radarControllerHeaderObj.nHeights=int(self.dataOut.radarControllerHeaderObj.samplingWindow['nsa']) | |||
|
|
664 | self.dataOut.radarControllerHeaderObj.firstHeight = self.dataOut.radarControllerHeaderObj.samplingWindow['h0'] | |||
|
|
665 | self.dataOut.radarControllerHeaderObj.deltaHeight = self.dataOut.radarControllerHeaderObj.samplingWindow['dh'] | |||
|
|
666 | self.dataOut.radarControllerHeaderObj.samplesWin = self.dataOut.radarControllerHeaderObj.samplingWindow['nsa'] | |||
|
|
667 | ||||
|
|
668 | self.dataOut.radarControllerHeaderObj.nWindows=1 | |||
|
|
669 | self.dataOut.radarControllerHeaderObj.codetype=0 | |||
|
|
670 | self.dataOut.radarControllerHeaderObj.numTaus=0 | |||
|
|
671 | #self.dataOut.radarControllerHeaderObj.Taus = numpy.zeros((1,),'<f4') | |||
|
|
672 | ||||
|
|
673 | ||||
|
|
674 | #self.dataOut.radarControllerHeaderObj.nCode=numpy.zeros((1,), '<u4') | |||
|
|
675 | #self.dataOut.radarControllerHeaderObj.nBaud=numpy.zeros((1,), '<u4') | |||
|
|
676 | #self.dataOut.radarControllerHeaderObj.code=numpy.zeros(0) | |||
|
|
677 | ||||
|
|
678 | self.dataOut.radarControllerHeaderObj.code_size=0 | |||
|
|
679 | self.dataOut.nBaud=0 | |||
|
|
680 | self.dataOut.nCode=0 | |||
|
|
681 | self.dataOut.nPairs=0 | |||
|
|
682 | ||||
|
|
683 | ||||
|
|
684 | #--------------------------------------------------------- | |||
|
|
685 | ||||
| 652 | self.dataOut.type = "Voltage" |
|
686 | self.dataOut.type = "Voltage" | |
| 653 |
|
687 | |||
| 654 | self.dataOut.data = None |
|
688 | self.dataOut.data = None | |
| 655 |
|
689 | |||
| 656 |
self.dataOut.dtype = numpy.dtype([('real','< |
|
690 | self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')]) | |
| 657 |
|
691 | |||
| 658 | self.dataOut.nProfiles = 1 |
|
692 | self.dataOut.nProfiles = 1 | |
| 659 |
|
693 | |||
| 660 | self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth |
|
694 | self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth | |
| 661 |
|
695 | |||
| 662 | self.dataOut.channelList = range(self.nChannels) |
|
696 | self.dataOut.channelList = range(self.nChannels) | |
| 663 |
|
697 | |||
| 664 | #self.dataOut.channelIndexList = None |
|
698 | #self.dataOut.channelIndexList = None | |
| 665 |
|
699 | |||
| 666 | self.dataOut.flagNoData = True |
|
700 | self.dataOut.flagNoData = True | |
| 667 |
|
701 | |||
| 668 | #Set to TRUE if the data is discontinuous |
|
702 | #Set to TRUE if the data is discontinuous | |
| 669 | self.dataOut.flagDiscontinuousBlock = False |
|
703 | self.dataOut.flagDiscontinuousBlock = False | |
| 670 |
|
704 | |||
| 671 | self.dataOut.utctime = None |
|
705 | self.dataOut.utctime = None | |
| 672 |
|
706 | |||
| 673 | self.dataOut.timeZone = 0 |
|
707 | self.dataOut.timeZone = 0 | |
| 674 |
|
708 | |||
| 675 | self.dataOut.dstFlag = 0 |
|
709 | self.dataOut.dstFlag = 0 | |
| 676 |
|
710 | |||
| 677 | self.dataOut.errorCount = 0 |
|
711 | self.dataOut.errorCount = 0 | |
| 678 |
|
712 | |||
| 679 | self.dataOut.nCohInt = 1 |
|
713 | self.dataOut.nCohInt = 1 | |
| 680 |
|
714 | |||
| 681 | self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights() |
|
715 | self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights() | |
| 682 |
|
716 | |||
| 683 | self.dataOut.flagDecodeData = False #asumo que la data esta decodificada |
|
717 | self.dataOut.flagDecodeData = False #asumo que la data esta decodificada | |
| 684 |
|
718 | |||
| 685 | self.dataOut.flagDeflipData = False #asumo que la data esta sin flip |
|
719 | self.dataOut.flagDeflipData = False #asumo que la data esta sin flip | |
| 686 |
|
720 | |||
| 687 | self.dataOut.flagShiftFFT = False |
|
721 | self.dataOut.flagShiftFFT = False | |
| 688 |
|
722 | |||
| 689 | self.dataOut.ippSeconds = 1.0*self.__nSamples/self.__sample_rate |
|
723 | self.dataOut.ippSeconds = 1.0*self.__nSamples/self.__sample_rate | |
| 690 |
|
724 | |||
| 691 | #Time interval between profiles |
|
725 | #Time interval between profiles | |
| 692 | #self.dataOut.timeInterval =self.dataOut.ippSeconds * self.dataOut.nCohInt |
|
726 | #self.dataOut.timeInterval =self.dataOut.ippSeconds * self.dataOut.nCohInt | |
| 693 |
|
727 | |||
| 694 |
|
728 | |||
| 695 | self.dataOut.frequency = self.__frequency |
|
729 | self.dataOut.frequency = self.__frequency | |
| 696 |
|
730 | |||
| 697 | self.dataOut.realtime = self.__online |
|
731 | self.dataOut.realtime = self.__online | |
| 698 |
|
732 | |||
| 699 | def __hasNotDataInBuffer(self): |
|
733 | def __hasNotDataInBuffer(self): | |
| 700 |
|
734 | |||
| 701 | if self.profileIndex >= self.nProfiles: |
|
735 | if self.profileIndex >= self.nProfiles: | |
| 702 | return 1 |
|
736 | return 1 | |
| 703 |
|
737 | |||
| 704 | return 0 |
|
738 | return 0 | |
| 705 |
|
739 | |||
| 706 | def readNextBlock(self): |
|
740 | def readNextBlock(self): | |
| 707 | if not(self.__setNewBlock()): |
|
741 | if not(self.__setNewBlock()): | |
| 708 | return 0 |
|
742 | return 0 | |
| 709 |
|
743 | |||
| 710 | if not(self.readBlock()): |
|
744 | if not(self.readBlock()): | |
| 711 | return 0 |
|
745 | return 0 | |
| 712 |
|
746 | |||
| 713 | return 1 |
|
747 | return 1 | |
| 714 |
|
748 | |||
| 715 | def __setNewBlock(self): |
|
749 | def __setNewBlock(self): | |
| 716 |
|
750 | |||
| 717 | if self.hfFilePointer==None: |
|
751 | if self.hfFilePointer==None: | |
| 718 | return 0 |
|
752 | return 0 | |
| 719 |
|
753 | |||
| 720 | if self.flagIsNewFile: |
|
754 | if self.flagIsNewFile: | |
| 721 | return 1 |
|
755 | return 1 | |
| 722 |
|
756 | |||
| 723 | if self.profileIndex < self.nProfiles: |
|
757 | if self.profileIndex < self.nProfiles: | |
| 724 | return 1 |
|
758 | return 1 | |
| 725 |
|
759 | |||
| 726 | self.__setNextFile(self.online) |
|
760 | self.__setNextFile(self.online) | |
| 727 |
|
761 | |||
| 728 | return 1 |
|
762 | return 1 | |
| 729 |
|
763 | |||
| 730 |
|
764 | |||
| 731 |
|
765 | |||
| 732 | def readBlock(self): |
|
766 | def readBlock(self): | |
| 733 | fp=h5py.File(self.filename,'r') |
|
767 | fp=h5py.File(self.filename,'r') | |
| 734 | #Puntero que apunta al archivo hdf5 |
|
768 | #Puntero que apunta al archivo hdf5 | |
| 735 | ch0=(fp['ch0']).value #Primer canal (100,1000)--(perfiles,alturas) |
|
769 | ch0=(fp['ch0']).value #Primer canal (100,1000)--(perfiles,alturas) | |
| 736 | ch1=(fp['ch1']).value #Segundo canal (100,1000)--(perfiles,alturas) |
|
770 | ch1=(fp['ch1']).value #Segundo canal (100,1000)--(perfiles,alturas) | |
| 737 | fp.close() |
|
771 | fp.close() | |
| 738 | ch0= ch0.swapaxes(0,1) #Primer canal (100,1000)--(alturas,perfiles) |
|
772 | ch0= ch0.swapaxes(0,1) #Primer canal (100,1000)--(alturas,perfiles) | |
| 739 | ch1= ch1.swapaxes(0,1) #Segundo canal (100,1000)--(alturas,perfiles) |
|
773 | ch1= ch1.swapaxes(0,1) #Segundo canal (100,1000)--(alturas,perfiles) | |
| 740 | self.datablock = numpy.array([ch0,ch1]) |
|
774 | self.datablock = numpy.array([ch0,ch1]) | |
| 741 | self.flagIsNewFile=0 |
|
775 | self.flagIsNewFile=0 | |
| 742 |
|
776 | |||
| 743 | self.profileIndex=0 |
|
777 | self.profileIndex=0 | |
| 744 |
|
778 | |||
| 745 | return 1 |
|
779 | return 1 | |
| 746 |
|
780 | |||
| 747 | def getData(self): |
|
781 | def getData(self): | |
| 748 | if self.flagNoMoreFiles: |
|
782 | if self.flagNoMoreFiles: | |
| 749 | self.dataOut.flagNoData = True |
|
783 | self.dataOut.flagNoData = True | |
| 750 | print 'Process finished' |
|
784 | print 'Process finished' | |
| 751 | return 0 |
|
785 | return 0 | |
| 752 |
|
786 | |||
| 753 | if self.__hasNotDataInBuffer(): |
|
787 | if self.__hasNotDataInBuffer(): | |
| 754 | if not(self.readNextBlock()): |
|
788 | if not(self.readNextBlock()): | |
| 755 | self.dataOut.flagNodata=True |
|
789 | self.dataOut.flagNodata=True | |
| 756 | return 0 |
|
790 | return 0 | |
| 757 |
|
791 | |||
| 758 | ############################## |
|
792 | ############################## | |
| 759 | ############################## |
|
793 | ############################## | |
| 760 | self.dataOut.data = self.datablock[:,:,self.profileIndex] |
|
794 | self.dataOut.data = self.datablock[:,:,self.profileIndex] | |
| 761 | self.dataOut.utctime= self.__t0 + self.dataOut.ippSeconds*self.profileIndex+self.timezone |
|
795 | self.dataOut.utctime= self.__t0 + self.dataOut.ippSeconds*self.profileIndex+self.timezone | |
| 762 | self.dataOut.profileIndex= self.profileIndex |
|
796 | self.dataOut.profileIndex= self.profileIndex | |
| 763 | self.dataOut.flagNoData=False |
|
797 | self.dataOut.flagNoData=False | |
| 764 | self.profileIndex +=1 |
|
798 | self.profileIndex +=1 | |
| 765 |
|
799 | |||
| 766 | return self.dataOut.data |
|
800 | return self.dataOut.data | |
| 767 |
|
801 | |||
| 768 |
|
802 | |||
| 769 | def run(self, **kwargs): |
|
803 | def run(self, **kwargs): | |
| 770 | ''' |
|
804 | ''' | |
| 771 | This method will be called many times so here you should put all your code |
|
805 | This method will be called many times so here you should put all your code | |
| 772 | ''' |
|
806 | ''' | |
| 773 |
|
807 | |||
| 774 | if not self.isConfig: |
|
808 | if not self.isConfig: | |
| 775 | self.setup(**kwargs) |
|
809 | self.setup(**kwargs) | |
| 776 | self.isConfig = True |
|
810 | self.isConfig = True | |
| 777 | self.getData() |
|
811 | self.getData() | |
| 778 |
|
812 | |||
| 779 |
|
813 | |||
| 780 |
|
814 | |||
| 781 | No newline at end of file |
|
815 | ||
General Comments 0
You need to be logged in to leave comments.
Login now