##// END OF EJS Templates
schain
RSS
update de operacion voltACFLags en jroproc_voltage.py y VoltACFPLot en jroplot_voltage.py
avaldez -
r1274:b6957aa66e1c
parent child
Show More
Side by Side Unified
Context file:
r1274:b6957aa66e1c Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,426 +1,400
1 1 '''
2 2 Created on Jul 9, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 6 import os
7 7 import datetime
8 8 import numpy
9 9
10 10 from figure import Figure
11 11 from plotting_codes import *
12 12
13 13 class Scope(Figure):
14 14
15 15 isConfig = None
16 16
17 17 def __init__(self, **kwargs):
18 18 Figure.__init__(self, **kwargs)
19 19 self.isConfig = False
20 20 self.WIDTH = 300
21 21 self.HEIGHT = 200
22 22 self.counter_imagwr = 0
23 23
24 24 def getSubplots(self):
25 25
26 26 nrow = self.nplots
27 27 ncol = 3
28 28 return nrow, ncol
29 29
30 30 def setup(self, id, nplots, wintitle, show):
31 31
32 32 self.nplots = nplots
33 33
34 34 self.createFigure(id=id,
35 35 wintitle=wintitle,
36 36 show=show)
37 37
38 38 nrow,ncol = self.getSubplots()
39 39 colspan = 3
40 40 rowspan = 1
41 41
42 42 for i in range(nplots):
43 43 self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
44 44
45 45 def plot_iq(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
46 46 yreal = y[channelIndexList,:].real
47 47 yimag = y[channelIndexList,:].imag
48 48
49 49 title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
50 50 xlabel = "Range (Km)"
51 51 ylabel = "Intensity - IQ"
52 52
53 53 if not self.isConfig:
54 54 nplots = len(channelIndexList)
55 55
56 56 self.setup(id=id,
57 57 nplots=nplots,
58 58 wintitle='',
59 59 show=show)
60 60
61 61 if xmin == None: xmin = numpy.nanmin(x)
62 62 if xmax == None: xmax = numpy.nanmax(x)
63 63 if ymin == None: ymin = min(numpy.nanmin(yreal),numpy.nanmin(yimag))
64 64 if ymax == None: ymax = max(numpy.nanmax(yreal),numpy.nanmax(yimag))
65 65
66 66 self.isConfig = True
67 67
68 68 self.setWinTitle(title)
69 69
70 70 for i in range(len(self.axesList)):
71 71 title = "Channel %d" %(i)
72 72 axes = self.axesList[i]
73 73
74 74 axes.pline(x, yreal[i,:],
75 75 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
76 76 xlabel=xlabel, ylabel=ylabel, title=title)
77 77
78 78 axes.addpline(x, yimag[i,:], idline=1, color="red", linestyle="solid", lw=2)
79 79
80 80 def plot_power(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
81 81 y = y[channelIndexList,:] * numpy.conjugate(y[channelIndexList,:])
82 82 yreal = y.real
83 83
84 84 title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
85 85 xlabel = "Range (Km)"
86 86 ylabel = "Intensity"
87 87
88 88 if not self.isConfig:
89 89 nplots = len(channelIndexList)
90 90
91 91 self.setup(id=id,
92 92 nplots=nplots,
93 93 wintitle='',
94 94 show=show)
95 95
96 96 if xmin == None: xmin = numpy.nanmin(x)
97 97 if xmax == None: xmax = numpy.nanmax(x)
98 98 if ymin == None: ymin = numpy.nanmin(yreal)
99 99 if ymax == None: ymax = numpy.nanmax(yreal)
100 100
101 101 self.isConfig = True
102 102
103 103 self.setWinTitle(title)
104 104
105 105 for i in range(len(self.axesList)):
106 106 title = "Channel %d" %(i)
107 107 axes = self.axesList[i]
108 108 ychannel = yreal[i,:]
109 109 axes.pline(x, ychannel,
110 110 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
111 111 xlabel=xlabel, ylabel=ylabel, title=title)
112 112
113 113
114 114 def run(self, dataOut, id, wintitle="", channelList=None,
115 115 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
116 116 figpath='./', figfile=None, show=True, wr_period=1,
117 117 ftp=False, server=None, folder=None, username=None, password=None, type='power', **kwargs):
118 118
119 119 """
120 120
121 121 Input:
122 122 dataOut :
123 123 id :
124 124 wintitle :
125 125 channelList :
126 126 xmin : None,
127 127 xmax : None,
128 128 ymin : None,
129 129 ymax : None,
130 130 """
131 131
132 132 if channelList == None:
133 133 channelIndexList = dataOut.channelIndexList
134 134 else:
135 135 channelIndexList = []
136 136 for channel in channelList:
137 137 if channel not in dataOut.channelList:
138 138 raise ValueError, "Channel %d is not in dataOut.channelList"
139 139 channelIndexList.append(dataOut.channelList.index(channel))
140 140
141 141 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
142 142
143 143 if dataOut.flagDataAsBlock:
144 144
145 145 for i in range(dataOut.nProfiles):
146 146
147 147 wintitle1 = wintitle + " [Profile = %d] " %i
148 148
149 149 if type == "power":
150 150 self.plot_power(dataOut.heightList,
151 151 dataOut.data[:,i,:],
152 152 id,
153 153 channelIndexList,
154 154 thisDatetime,
155 155 wintitle1,
156 156 show,
157 157 xmin,
158 158 xmax,
159 159 ymin,
160 160 ymax)
161 161
162 162 if type == "iq":
163 163 self.plot_iq(dataOut.heightList,
164 164 dataOut.data[:,i,:],
165 165 id,
166 166 channelIndexList,
167 167 thisDatetime,
168 168 wintitle1,
169 169 show,
170 170 xmin,
171 171 xmax,
172 172 ymin,
173 173 ymax)
174 174
175 175 self.draw()
176 176
177 177 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
178 178 figfile = self.getFilename(name = str_datetime) + "_" + str(i)
179 179
180 180 self.save(figpath=figpath,
181 181 figfile=figfile,
182 182 save=save,
183 183 ftp=ftp,
184 184 wr_period=wr_period,
185 185 thisDatetime=thisDatetime)
186 186
187 187 else:
188 188 wintitle += " [Profile = %d] " %dataOut.profileIndex
189 189
190 190 if type == "power":
191 191 self.plot_power(dataOut.heightList,
192 192 dataOut.data,
193 193 id,
194 194 channelIndexList,
195 195 thisDatetime,
196 196 wintitle,
197 197 show,
198 198 xmin,
199 199 xmax,
200 200 ymin,
201 201 ymax)
202 202
203 203 if type == "iq":
204 204 self.plot_iq(dataOut.heightList,
205 205 dataOut.data,
206 206 id,
207 207 channelIndexList,
208 208 thisDatetime,
209 209 wintitle,
210 210 show,
211 211 xmin,
212 212 xmax,
213 213 ymin,
214 214 ymax)
215 215
216 216 self.draw()
217 217
218 218 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S") + "_" + str(dataOut.profileIndex)
219 219 figfile = self.getFilename(name = str_datetime)
220 220
221 221 self.save(figpath=figpath,
222 222 figfile=figfile,
223 223 save=save,
224 224 ftp=ftp,
225 225 wr_period=wr_period,
226 226 thisDatetime=thisDatetime)
227 227
228 228
229 229 class VoltACFPLot(Figure):
230 230
231 231 isConfig = None
232 232 __nsubplots = None
233 233 PREFIX = 'voltacf'
234 234
235 235 def __init__(self, **kwargs):
236 236 Figure.__init__(self,**kwargs)
237 237 self.isConfig = False
238 238 self.__nsubplots = 1
239 239 self.PLOT_CODE = VOLT_ACF_CODE
240 240 self.WIDTH = 900
241 241 self.HEIGHT = 700
242 242 self.counter_imagwr= 0
243 243 self.FTP_WEI = None
244 244 self.EXP_CODE = None
245 245 self.SUB_EXP_CODE = None
246 246 self.PLOT_POS = None
247 247
248 248 def getSubplots(self) :
249 249 ncol = 1
250 250 nrow = 1
251 251 return nrow, ncol
252 252
253 253 def setup(self,id, nplots,wintitle,show):
254 254 self.nplots = nplots
255 255 ncolspan = 1
256 256 colspan = 1
257 257 self.createFigure(id=id,
258 258 wintitle = wintitle,
259 259 widthplot = self.WIDTH,
260 260 heightplot = self.HEIGHT,
261 261 show = show)
262
262 263 nrow, ncol = self.getSubplots()
263 264 counter = 0
265
264 266 for y in range(nrow):
265 267 for x in range(ncol):
266 268 self.addAxes(nrow, ncol*ncolspan,y, x*ncolspan, colspan, 1)
267 269
268 270 def run(self,dataOut, id, wintitle="",channelList = None , channel =None, nSamples = None,
269 271 nSampleList= None, resolutionFactor=None, xmin= None, xmax = None, ymin=None, ymax=None,
270 272 save= False, figpath='./', figfile= None,show= True, ftp= False, wr_period=1, server= None,
271 273 folder= None, username =None, password= None, ftp_wei=0 , exp_code=0,sub_exp_code=0,plot_pos=0,
272 274 xaxis="time"):
273 275
274 276 channel0 = channel
275 277 nSamples = nSamples
276 278 resFactor = resolutionFactor
277 279
278 280 if nSamples == None:
279 281 nSamples = 20
280 282
281 283 if resFactor == None:
282 284 resFactor = 5
283 285
284 286 if channel0 == None:
285 287 channel0 = 0
286 288 else:
287 289 if channel0 not in dataOut.channelList:
288 290 raise ValueError, "Channel %d is not in %s dataOut.channelList"%(channel0, dataOut.channelList)
289 291
290 292 if channelList == None:
291 293 channelIndexList = dataOut.channelIndexList
292 294 channelList = dataOut.channelList
293 295
294 296 else:
295 297 channelIndexList = []
296 298 for channel in channelList:
297 299 if channel not in dataOut.channelList:
298 300 raise ValueError, "Channel %d is not in dataOut.channelList"
299 301 channelIndexList.append(dataOut.channelList.index(channel))
300 302
301
302 303 #factor = dataOut.normFactor
303 304 y = dataOut.getHeiRange()
304 305 #print y, dataOut.heightList[0]
305 306 #print "pause"
306 307 #import time
307 308 #time.sleep(10)
308 309 deltaHeight = dataOut.heightList[1]-dataOut.heightList[0]
309 z = dataOut.data
310 z = dataOut.data_acfLag
311
312 shape = dataOut.data_acfLag.shape
310 313
311 shape = dataOut.data.shape
312 314 hei_index = numpy.arange(shape[2])
313 315 hei_plot = numpy.arange(nSamples)*resFactor
314 316
315 317 if nSampleList is not None:
316 318 for nsample in nSampleList:
317 319 if nsample not in dataOut.heightList/deltaHeight:
318 320 print "Lista available : %s "%(dataOut.heightList/deltaHeight)
319 321 raise ValueError, "nsample %d is not in %s dataOut.heightList"%(nsample,dataOut.heightList)
320 322
321 323 if nSampleList is not None:
322 324 hei_plot = numpy.array(nSampleList)*resFactor
323 325
324 326 if hei_plot[-1] >= hei_index[-1]:
325 327 print ("La cantidad de puntos en altura es %d y la resolucion es %f Km"%(hei_plot.shape[0],deltaHeight*resFactor ))
326 328 raise ValueError, "resFactor %d multiplicado por el valor de %d nSamples es mayor a %d cantidad total de puntos"%(resFactor,nSamples,hei_index[-1])
327 329
328 330 #escalamiento -1 a 1 a resolucion (factor de resolucion en altura)* deltaHeight
329 331 #min = numpy.min(z[0,:,0])
330 332 #max =numpy.max(z[0,:,0])
333 #print shape[0]
331 334 for i in range(shape[0]):
335 #print "amigo i",i
332 336 for j in range(shape[2]):
333 337 min = numpy.min(z[i,:,j])
334 338 max = numpy.max(z[i,:,j])
335 339 z[i,:,j]= (((z[i,:,j]-min)/(max-min))*deltaHeight*resFactor + j*deltaHeight+dataOut.heightList[0])
336 340
337
338 341 if xaxis == "time":
339 342 x = dataOut.getAcfRange()*1000
340 343 zdB = z[channel0,:,hei_plot]
341 344 xlabel = "Time (ms)"
342 345 ylabel = "VOLT_ACF"
343
344
345 346 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
346 347 title = wintitle + "VOLT ACF Plot Ch %s %s" %(channel0,thisDatetime.strftime("%d-%b-%Y"))
347 348
348 349 if not self.isConfig:
349 350
350 351 nplots = 1
351 352
352 353 self.setup(id=id,
353 354 nplots=nplots,
354 355 wintitle=wintitle,
355 356 show=show)
356 357
357 358 if xmin == None: xmin = numpy.nanmin(x)#*0.9
358 359 if xmax == None: xmax = numpy.nanmax(x)#*1.1
359 360 if ymin == None: ymin = numpy.nanmin(zdB)
360 361 if ymax == None: ymax = numpy.nanmax(zdB)
361 362
362 363 print ("El parametro resFactor es %d y la resolucion en altura es %f"%(resFactor,deltaHeight ))
363 364 print ("La cantidad de puntos en altura es %d y la nueva resolucion es %f Km"%(hei_plot.shape[0],deltaHeight*resFactor ))
364 365 print ("La altura maxima es %d Km"%(hei_plot[-1]*deltaHeight ))
365 366
366 367 self.FTP_WEI = ftp_wei
367 368 self.EXP_CODE = exp_code
368 369 self.SUB_EXP_CODE = sub_exp_code
369 370 self.PLOT_POS = plot_pos
370 371
371 372 self.isConfig = True
372 373
373 374 self.setWinTitle(title)
374
375 375 title = "VOLT ACF Plot: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
376 376 axes = self.axesList[0]
377 377
378 378 legendlabels = ["Range = %dKm" %y[i] for i in hei_plot]
379 379
380 380 axes.pmultilineyaxis( x, zdB,
381 381 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
382 382 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
383 383 ytick_visible=True, nxticks=5,
384 384 grid='x')
385 385
386 386 self.draw()
387 387
388 388 if figfile == None:
389 389 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
390 390 name = str_datetime
391 391 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
392 392 name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
393 393 figfile = self.getFilename(name)
394 394
395 395 self.save(figpath=figpath,
396 396 figfile=figfile,
397 397 save=save,
398 398 ftp=ftp,
399 399 wr_period=wr_period,
400 400 thisDatetime=thisDatetime)
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
Show file before | Show file after | Hide comments
@@ -1,1682 +1,1686
1 1 import sys
2 2 import numpy
3 3 from scipy import interpolate
4 4 from schainpy import cSchain
5 5 from jroproc_base import ProcessingUnit, Operation
6 6 from schainpy.model.data.jrodata import Voltage
7 7 from time import time
8 8
9 9 import math
10 10
11 11 def rep_seq(x, rep=10):
12 12 L = len(x) * rep
13 13 res = numpy.zeros(L, dtype=x.dtype)
14 14 idx = numpy.arange(len(x)) * rep
15 15 for i in numpy.arange(rep):
16 16 res[idx + i] = x
17 17 return(res)
18 18
19 19
20 20 def create_pseudo_random_code(clen=10000, seed=0):
21 21 """
22 22 seed is a way of reproducing the random code without
23 23 having to store all actual codes. the seed can then
24 24 act as a sort of station_id.
25 25
26 26 """
27 27 numpy.random.seed(seed)
28 28 phases = numpy.array(
29 29 numpy.exp(1.0j * 2.0 * math.pi * numpy.random.random(clen)),
30 30 dtype=numpy.complex64,
31 31 )
32 32 return(phases)
33 33
34 34
35 35 def periodic_convolution_matrix(envelope, rmin=0, rmax=100):
36 36 """
37 37 we imply that the number of measurements is equal to the number of elements
38 38 in code
39 39
40 40 """
41 41 L = len(envelope)
42 42 ridx = numpy.arange(rmin, rmax)
43 43 A = numpy.zeros([L, rmax-rmin], dtype=numpy.complex64)
44 44 for i in numpy.arange(L):
45 45 A[i, :] = envelope[(i-ridx) % L]
46 46 result = {}
47 47 result['A'] = A
48 48 result['ridx'] = ridx
49 49 return(result)
50 50
51 51
52 52 B_cache = 0
53 53 r_cache = 0
54 54 B_cached = False
55 55 def create_estimation_matrix(code, rmin=0, rmax=1000, cache=True):
56 56 global B_cache
57 57 global r_cache
58 58 global B_cached
59 59
60 60 if not cache or not B_cached:
61 61 r_cache = periodic_convolution_matrix(
62 62 envelope=code, rmin=rmin, rmax=rmax,
63 63 )
64 64 A = r_cache['A']
65 65 Ah = numpy.transpose(numpy.conjugate(A))
66 66 B_cache = numpy.dot(numpy.linalg.inv(numpy.dot(Ah, A)), Ah)
67 67 r_cache['B'] = B_cache
68 68 B_cached = True
69 69 return(r_cache)
70 70 else:
71 71 return(r_cache)
72 72
73 73 class VoltageProc(ProcessingUnit):
74 74
75 75
76 76 def __init__(self, **kwargs):
77 77
78 78 ProcessingUnit.__init__(self, **kwargs)
79 79
80 80 # self.objectDict = {}
81 81 self.dataOut = Voltage()
82 82 self.flip = 1
83 83
84 84 def run(self):
85 85 if self.dataIn.type == 'AMISR':
86 86 self.__updateObjFromAmisrInput()
87 87
88 88 if self.dataIn.type == 'Voltage':
89 89 self.dataOut.copy(self.dataIn)
90 90
91 91 # self.dataOut.copy(self.dataIn)
92 92
93 93 def __updateObjFromAmisrInput(self):
94 94
95 95 self.dataOut.timeZone = self.dataIn.timeZone
96 96 self.dataOut.dstFlag = self.dataIn.dstFlag
97 97 self.dataOut.errorCount = self.dataIn.errorCount
98 98 self.dataOut.useLocalTime = self.dataIn.useLocalTime
99 99
100 100 self.dataOut.flagNoData = self.dataIn.flagNoData
101 101 self.dataOut.data = self.dataIn.data
102 102 self.dataOut.utctime = self.dataIn.utctime
103 103 self.dataOut.channelList = self.dataIn.channelList
104 104 # self.dataOut.timeInterval = self.dataIn.timeInterval
105 105 self.dataOut.heightList = self.dataIn.heightList
106 106 self.dataOut.nProfiles = self.dataIn.nProfiles
107 107
108 108 self.dataOut.nCohInt = self.dataIn.nCohInt
109 109 self.dataOut.ippSeconds = self.dataIn.ippSeconds
110 110 self.dataOut.frequency = self.dataIn.frequency
111 111
112 112 self.dataOut.azimuth = self.dataIn.azimuth
113 113 self.dataOut.zenith = self.dataIn.zenith
114 114
115 115 self.dataOut.beam.codeList = self.dataIn.beam.codeList
116 116 self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
117 117 self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
118 118 #
119 119 # pass#
120 120 #
121 121 # def init(self):
122 122 #
123 123 #
124 124 # if self.dataIn.type == 'AMISR':
125 125 # self.__updateObjFromAmisrInput()
126 126 #
127 127 # if self.dataIn.type == 'Voltage':
128 128 # self.dataOut.copy(self.dataIn)
129 129 # # No necesita copiar en cada init() los atributos de dataIn
130 130 # # la copia deberia hacerse por cada nuevo bloque de datos
131 131
132 132 def selectChannels(self, channelList):
133 133
134 134 channelIndexList = []
135 135
136 136 for channel in channelList:
137 137 if channel not in self.dataOut.channelList:
138 138 raise ValueError, "Channel %d is not in %s" %(channel, str(self.dataOut.channelList))
139 139
140 140 index = self.dataOut.channelList.index(channel)
141 141 channelIndexList.append(index)
142 142
143 143 self.selectChannelsByIndex(channelIndexList)
144 144
145 145 def selectChannelsByIndex(self, channelIndexList):
146 146 """
147 147 Selecciona un bloque de datos en base a canales segun el channelIndexList
148 148
149 149 Input:
150 150 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
151 151
152 152 Affected:
153 153 self.dataOut.data
154 154 self.dataOut.channelIndexList
155 155 self.dataOut.nChannels
156 156 self.dataOut.m_ProcessingHeader.totalSpectra
157 157 self.dataOut.systemHeaderObj.numChannels
158 158 self.dataOut.m_ProcessingHeader.blockSize
159 159
160 160 Return:
161 161 None
162 162 """
163 163
164 164 for channelIndex in channelIndexList:
165 165 if channelIndex not in self.dataOut.channelIndexList:
166 166 print channelIndexList
167 167 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
168 168
169 169 if self.dataOut.flagDataAsBlock:
170 170 """
171 171 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
172 172 """
173 173 data = self.dataOut.data[channelIndexList,:,:]
174 174 else:
175 175 data = self.dataOut.data[channelIndexList,:]
176 176
177 177 self.dataOut.data = data
178 178 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
179 179 # self.dataOut.nChannels = nChannels
180 180
181 181 return 1
182 182
183 183 def selectHeights(self, minHei=None, maxHei=None):
184 184 """
185 185 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
186 186 minHei <= height <= maxHei
187 187
188 188 Input:
189 189 minHei : valor minimo de altura a considerar
190 190 maxHei : valor maximo de altura a considerar
191 191
192 192 Affected:
193 193 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
194 194
195 195 Return:
196 196 1 si el metodo se ejecuto con exito caso contrario devuelve 0
197 197 """
198 198
199 199 if minHei == None:
200 200 minHei = self.dataOut.heightList[0]
201 201
202 202 if maxHei == None:
203 203 maxHei = self.dataOut.heightList[-1]
204 204
205 205 if (minHei < self.dataOut.heightList[0]):
206 206 minHei = self.dataOut.heightList[0]
207 207
208 208 if (maxHei > self.dataOut.heightList[-1]):
209 209 maxHei = self.dataOut.heightList[-1]
210 210
211 211 minIndex = 0
212 212 maxIndex = 0
213 213 heights = self.dataOut.heightList
214 214
215 215 inda = numpy.where(heights >= minHei)
216 216 indb = numpy.where(heights <= maxHei)
217 217
218 218 try:
219 219 minIndex = inda[0][0]
220 220 except:
221 221 minIndex = 0
222 222
223 223 try:
224 224 maxIndex = indb[0][-1]
225 225 except:
226 226 maxIndex = len(heights)
227 227
228 228 self.selectHeightsByIndex(minIndex, maxIndex)
229 229
230 230 return 1
231 231
232 232
233 233 def selectHeightsByIndex(self, minIndex, maxIndex):
234 234 """
235 235 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
236 236 minIndex <= index <= maxIndex
237 237
238 238 Input:
239 239 minIndex : valor de indice minimo de altura a considerar
240 240 maxIndex : valor de indice maximo de altura a considerar
241 241
242 242 Affected:
243 243 self.dataOut.data
244 244 self.dataOut.heightList
245 245
246 246 Return:
247 247 1 si el metodo se ejecuto con exito caso contrario devuelve 0
248 248 """
249 249
250 250 if (minIndex < 0) or (minIndex > maxIndex):
251 251 raise ValueError, "Height index range (%d,%d) is not valid" % (minIndex, maxIndex)
252 252
253 253 if (maxIndex >= self.dataOut.nHeights):
254 254 maxIndex = self.dataOut.nHeights
255 255
256 256 #voltage
257 257 if self.dataOut.flagDataAsBlock:
258 258 """
259 259 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
260 260 """
261 261 data = self.dataOut.data[:,:, minIndex:maxIndex]
262 262 else:
263 263 data = self.dataOut.data[:, minIndex:maxIndex]
264 264
265 265 # firstHeight = self.dataOut.heightList[minIndex]
266 266
267 267 self.dataOut.data = data
268 268 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex]
269 269
270 270 if self.dataOut.nHeights <= 1:
271 271 raise ValueError, "selectHeights: Too few heights. Current number of heights is %d" %(self.dataOut.nHeights)
272 272
273 273 return 1
274 274
275 275
276 276 def filterByHeights(self, window):
277 277
278 278 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
279 279
280 280 if window == None:
281 281 window = (self.dataOut.radarControllerHeaderObj.txA/self.dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
282 282
283 283 newdelta = deltaHeight * window
284 284 r = self.dataOut.nHeights % window
285 285 newheights = (self.dataOut.nHeights-r)/window
286 286
287 287 if newheights <= 1:
288 288 raise ValueError, "filterByHeights: Too few heights. Current number of heights is %d and window is %d" %(self.dataOut.nHeights, window)
289 289
290 290 if self.dataOut.flagDataAsBlock:
291 291 """
292 292 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
293 293 """
294 294 buffer = self.dataOut.data[:, :, 0:self.dataOut.nHeights-r]
295 295 buffer = buffer.reshape(self.dataOut.nChannels,self.dataOut.nProfiles,self.dataOut.nHeights/window,window)
296 296 buffer = numpy.sum(buffer,3)
297 297
298 298 else:
299 299 buffer = self.dataOut.data[:,0:self.dataOut.nHeights-r]
300 300 buffer = buffer.reshape(self.dataOut.nChannels,self.dataOut.nHeights/window,window)
301 301 buffer = numpy.sum(buffer,2)
302 302
303 303 self.dataOut.data = buffer
304 304 self.dataOut.heightList = self.dataOut.heightList[0] + numpy.arange( newheights )*newdelta
305 305 self.dataOut.windowOfFilter = window
306 306
307 307 def setH0(self, h0, deltaHeight = None):
308 308
309 309 if not deltaHeight:
310 310 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
311 311
312 312 nHeights = self.dataOut.nHeights
313 313
314 314 newHeiRange = h0 + numpy.arange(nHeights)*deltaHeight
315 315
316 316 self.dataOut.heightList = newHeiRange
317 317
318 318 def deFlip(self, channelList = []):
319 319
320 320 data = self.dataOut.data.copy()
321 321
322 322 if self.dataOut.flagDataAsBlock:
323 323 flip = self.flip
324 324 profileList = range(self.dataOut.nProfiles)
325 325
326 326 if not channelList:
327 327 for thisProfile in profileList:
328 328 data[:,thisProfile,:] = data[:,thisProfile,:]*flip
329 329 flip *= -1.0
330 330 else:
331 331 for thisChannel in channelList:
332 332 if thisChannel not in self.dataOut.channelList:
333 333 continue
334 334
335 335 for thisProfile in profileList:
336 336 data[thisChannel,thisProfile,:] = data[thisChannel,thisProfile,:]*flip
337 337 flip *= -1.0
338 338
339 339 self.flip = flip
340 340
341 341 else:
342 342 if not channelList:
343 343 data[:,:] = data[:,:]*self.flip
344 344 else:
345 345 for thisChannel in channelList:
346 346 if thisChannel not in self.dataOut.channelList:
347 347 continue
348 348
349 349 data[thisChannel,:] = data[thisChannel,:]*self.flip
350 350
351 351 self.flip *= -1.
352 352
353 353 self.dataOut.data = data
354 354
355 355 def setRadarFrequency(self, frequency=None):
356 356
357 357 if frequency != None:
358 358 self.dataOut.frequency = frequency
359 359
360 360 return 1
361 361
362 362 def interpolateHeights(self, topLim, botLim):
363 363 #69 al 72 para julia
364 364 #82-84 para meteoros
365 365 if len(numpy.shape(self.dataOut.data))==2:
366 366 sampInterp = (self.dataOut.data[:,botLim-1] + self.dataOut.data[:,topLim+1])/2
367 367 sampInterp = numpy.transpose(numpy.tile(sampInterp,(topLim-botLim + 1,1)))
368 368 #self.dataOut.data[:,botLim:limSup+1] = sampInterp
369 369 self.dataOut.data[:,botLim:topLim+1] = sampInterp
370 370 else:
371 371 nHeights = self.dataOut.data.shape[2]
372 372 x = numpy.hstack((numpy.arange(botLim),numpy.arange(topLim+1,nHeights)))
373 373 y = self.dataOut.data[:,:,range(botLim)+range(topLim+1,nHeights)]
374 374 f = interpolate.interp1d(x, y, axis = 2)
375 375 xnew = numpy.arange(botLim,topLim+1)
376 376 ynew = f(xnew)
377 377
378 378 self.dataOut.data[:,:,botLim:topLim+1] = ynew
379 379
380 380 # import collections
381 381
382 382 class CohInt(Operation):
383 383
384 384 isConfig = False
385 385 __profIndex = 0
386 386 __byTime = False
387 387 __initime = None
388 388 __lastdatatime = None
389 389 __integrationtime = None
390 390 __buffer = None
391 391 __bufferStride = []
392 392 __dataReady = False
393 393 __profIndexStride = 0
394 394 __dataToPutStride = False
395 395 n = None
396 396
397 397 def __init__(self, **kwargs):
398 398
399 399 Operation.__init__(self, **kwargs)
400 400
401 401 # self.isConfig = False
402 402
403 403 def setup(self, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False):
404 404 """
405 405 Set the parameters of the integration class.
406 406
407 407 Inputs:
408 408
409 409 n : Number of coherent integrations
410 410 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
411 411 overlapping :
412 412 """
413 413
414 414 self.__initime = None
415 415 self.__lastdatatime = 0
416 416 self.__buffer = None
417 417 self.__dataReady = False
418 418 self.byblock = byblock
419 419 self.stride = stride
420 420
421 421 if n == None and timeInterval == None:
422 422 raise ValueError, "n or timeInterval should be specified ..."
423 423
424 424 if n != None:
425 425 self.n = n
426 426 self.__byTime = False
427 427 else:
428 428 self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
429 429 self.n = 9999
430 430 self.__byTime = True
431 431
432 432 if overlapping:
433 433 self.__withOverlapping = True
434 434 self.__buffer = None
435 435 else:
436 436 self.__withOverlapping = False
437 437 self.__buffer = 0
438 438
439 439 self.__profIndex = 0
440 440
441 441 def putData(self, data):
442 442
443 443 """
444 444 Add a profile to the __buffer and increase in one the __profileIndex
445 445
446 446 """
447 447
448 448 if not self.__withOverlapping:
449 449 self.__buffer += data.copy()
450 450 self.__profIndex += 1
451 451 return
452 452
453 453 #Overlapping data
454 454 nChannels, nHeis = data.shape
455 455 data = numpy.reshape(data, (1, nChannels, nHeis))
456 456
457 457 #If the buffer is empty then it takes the data value
458 458 if self.__buffer is None:
459 459 self.__buffer = data
460 460 self.__profIndex += 1
461 461 return
462 462
463 463 #If the buffer length is lower than n then stakcing the data value
464 464 if self.__profIndex < self.n:
465 465 self.__buffer = numpy.vstack((self.__buffer, data))
466 466 self.__profIndex += 1
467 467 return
468 468
469 469 #If the buffer length is equal to n then replacing the last buffer value with the data value
470 470 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
471 471 self.__buffer[self.n-1] = data
472 472 self.__profIndex = self.n
473 473 return
474 474
475 475
476 476 def pushData(self):
477 477 """
478 478 Return the sum of the last profiles and the profiles used in the sum.
479 479
480 480 Affected:
481 481
482 482 self.__profileIndex
483 483
484 484 """
485 485
486 486 if not self.__withOverlapping:
487 487 data = self.__buffer
488 488 n = self.__profIndex
489 489
490 490 self.__buffer = 0
491 491 self.__profIndex = 0
492 492
493 493 return data, n
494 494
495 495 #Integration with Overlapping
496 496 data = numpy.sum(self.__buffer, axis=0)
497 497 # print data
498 498 # raise
499 499 n = self.__profIndex
500 500
501 501 return data, n
502 502
503 503 def byProfiles(self, data):
504 504
505 505 self.__dataReady = False
506 506 avgdata = None
507 507 # n = None
508 508 # print data
509 509 # raise
510 510 self.putData(data)
511 511
512 512 if self.__profIndex == self.n:
513 513 avgdata, n = self.pushData()
514 514 self.__dataReady = True
515 515
516 516 return avgdata
517 517
518 518 def byTime(self, data, datatime):
519 519
520 520 self.__dataReady = False
521 521 avgdata = None
522 522 n = None
523 523
524 524 self.putData(data)
525 525
526 526 if (datatime - self.__initime) >= self.__integrationtime:
527 527 avgdata, n = self.pushData()
528 528 self.n = n
529 529 self.__dataReady = True
530 530
531 531 return avgdata
532 532
533 533 def integrateByStride(self, data, datatime):
534 534 # print data
535 535 if self.__profIndex == 0:
536 536 self.__buffer = [[data.copy(), datatime]]
537 537 else:
538 538 self.__buffer.append([data.copy(),datatime])
539 539 self.__profIndex += 1
540 540 self.__dataReady = False
541 541
542 542 if self.__profIndex == self.n * self.stride :
543 543 self.__dataToPutStride = True
544 544 self.__profIndexStride = 0
545 545 self.__profIndex = 0
546 546 self.__bufferStride = []
547 547 for i in range(self.stride):
548 548 current = self.__buffer[i::self.stride]
549 549 data = numpy.sum([t[0] for t in current], axis=0)
550 550 avgdatatime = numpy.average([t[1] for t in current])
551 551 # print data
552 552 self.__bufferStride.append((data, avgdatatime))
553 553
554 554 if self.__dataToPutStride:
555 555 self.__dataReady = True
556 556 self.__profIndexStride += 1
557 557 if self.__profIndexStride == self.stride:
558 558 self.__dataToPutStride = False
559 559 # print self.__bufferStride[self.__profIndexStride - 1]
560 560 # raise
561 561 return self.__bufferStride[self.__profIndexStride - 1]
562 562
563 563
564 564 return None, None
565 565
566 566 def integrate(self, data, datatime=None):
567 567
568 568 if self.__initime == None:
569 569 self.__initime = datatime
570 570
571 571 if self.__byTime:
572 572 avgdata = self.byTime(data, datatime)
573 573 else:
574 574 avgdata = self.byProfiles(data)
575 575
576 576
577 577 self.__lastdatatime = datatime
578 578
579 579 if avgdata is None:
580 580 return None, None
581 581
582 582 avgdatatime = self.__initime
583 583
584 584 deltatime = datatime - self.__lastdatatime
585 585
586 586 if not self.__withOverlapping:
587 587 self.__initime = datatime
588 588 else:
589 589 self.__initime += deltatime
590 590
591 591 return avgdata, avgdatatime
592 592
593 593 def integrateByBlock(self, dataOut):
594 594
595 595 times = int(dataOut.data.shape[1]/self.n)
596 596 avgdata = numpy.zeros((dataOut.nChannels, times, dataOut.nHeights), dtype=numpy.complex)
597 597
598 598 id_min = 0
599 599 id_max = self.n
600 600
601 601 for i in range(times):
602 602 junk = dataOut.data[:,id_min:id_max,:]
603 603 avgdata[:,i,:] = junk.sum(axis=1)
604 604 id_min += self.n
605 605 id_max += self.n
606 606
607 607 timeInterval = dataOut.ippSeconds*self.n
608 608 avgdatatime = (times - 1) * timeInterval + dataOut.utctime
609 609 self.__dataReady = True
610 610 return avgdata, avgdatatime
611 611
612 612 def run(self, dataOut, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False, **kwargs):
613 613 if not self.isConfig:
614 614 self.setup(n=n, stride=stride, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
615 615 self.isConfig = True
616 616
617 617 if dataOut.flagDataAsBlock:
618 618 """
619 619 Si la data es leida por bloques, dimension = [nChannels, nProfiles, nHeis]
620 620 """
621 621 avgdata, avgdatatime = self.integrateByBlock(dataOut)
622 622 dataOut.nProfiles /= self.n
623 623 else:
624 624 if stride is None:
625 625 avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
626 626 else:
627 627 avgdata, avgdatatime = self.integrateByStride(dataOut.data, dataOut.utctime)
628 628
629 629
630 630 # dataOut.timeInterval *= n
631 631 dataOut.flagNoData = True
632 632
633 633 if self.__dataReady:
634 634 dataOut.data = avgdata
635 635 dataOut.nCohInt *= self.n
636 636 dataOut.utctime = avgdatatime
637 637 # print avgdata, avgdatatime
638 638 # raise
639 639 # dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
640 640 dataOut.flagNoData = False
641 641
642 642 class Decoder(Operation):
643 643
644 644 isConfig = False
645 645 __profIndex = 0
646 646
647 647 code = None
648 648
649 649 nCode = None
650 650 nBaud = None
651 651
652 652 def __init__(self, **kwargs):
653 653
654 654 Operation.__init__(self, **kwargs)
655 655
656 656 self.times = None
657 657 self.osamp = None
658 658 # self.__setValues = False
659 659 self.isConfig = False
660 660
661 661 def setup(self, code, osamp, dataOut):
662 662
663 663 self.__profIndex = 0
664 664
665 665 self.code = code
666 666
667 667 self.nCode = len(code)
668 668 self.nBaud = len(code[0])
669 669
670 670 if (osamp != None) and (osamp >1):
671 671 self.osamp = osamp
672 672 self.code = numpy.repeat(code, repeats=self.osamp, axis=1)
673 673 self.nBaud = self.nBaud*self.osamp
674 674
675 675 self.__nChannels = dataOut.nChannels
676 676 self.__nProfiles = dataOut.nProfiles
677 677 self.__nHeis = dataOut.nHeights
678 678
679 679 if self.__nHeis < self.nBaud:
680 680 raise ValueError, 'Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud)
681 681
682 682 #Frequency
683 683 __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
684 684
685 685 __codeBuffer[:,0:self.nBaud] = self.code
686 686
687 687 self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
688 688
689 689 if dataOut.flagDataAsBlock:
690 690
691 691 self.ndatadec = self.__nHeis #- self.nBaud + 1
692 692
693 693 self.datadecTime = numpy.zeros((self.__nChannels, self.__nProfiles, self.ndatadec), dtype=numpy.complex)
694 694
695 695 else:
696 696
697 697 #Time
698 698 self.ndatadec = self.__nHeis #- self.nBaud + 1
699 699
700 700 self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
701 701
702 702 def __convolutionInFreq(self, data):
703 703
704 704 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
705 705
706 706 fft_data = numpy.fft.fft(data, axis=1)
707 707
708 708 conv = fft_data*fft_code
709 709
710 710 data = numpy.fft.ifft(conv,axis=1)
711 711
712 712 return data
713 713
714 714 def __convolutionInFreqOpt(self, data):
715 715
716 716 raise NotImplementedError
717 717
718 718 def __convolutionInTime(self, data):
719 719
720 720 code = self.code[self.__profIndex]
721 721 for i in range(self.__nChannels):
722 722 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='full')[self.nBaud-1:]
723 723
724 724 return self.datadecTime
725 725
726 726 def __convolutionByBlockInTime(self, data):
727 727
728 728 repetitions = self.__nProfiles / self.nCode
729 729
730 730 junk = numpy.lib.stride_tricks.as_strided(self.code, (repetitions, self.code.size), (0, self.code.itemsize))
731 731 junk = junk.flatten()
732 732 code_block = numpy.reshape(junk, (self.nCode*repetitions, self.nBaud))
733 733 profilesList = xrange(self.__nProfiles)
734 734
735 735 for i in range(self.__nChannels):
736 736 for j in profilesList:
737 737 self.datadecTime[i,j,:] = numpy.correlate(data[i,j,:], code_block[j,:], mode='full')[self.nBaud-1:]
738 738 return self.datadecTime
739 739
740 740 def __convolutionByBlockInFreq(self, data):
741 741
742 742 raise NotImplementedError, "Decoder by frequency fro Blocks not implemented"
743 743
744 744
745 745 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
746 746
747 747 fft_data = numpy.fft.fft(data, axis=2)
748 748
749 749 conv = fft_data*fft_code
750 750
751 751 data = numpy.fft.ifft(conv,axis=2)
752 752
753 753 return data
754 754
755 755
756 756 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0, osamp=None, times=None):
757 757
758 758 if dataOut.flagDecodeData:
759 759 print "This data is already decoded, recoding again ..."
760 760
761 761 if not self.isConfig:
762 762
763 763 if code is None:
764 764 if dataOut.code is None:
765 765 raise ValueError, "Code could not be read from %s instance. Enter a value in Code parameter" %dataOut.type
766 766
767 767 code = dataOut.code
768 768 else:
769 769 code = numpy.array(code).reshape(nCode,nBaud)
770 770 self.setup(code, osamp, dataOut)
771 771
772 772 self.isConfig = True
773 773
774 774 if mode == 3:
775 775 sys.stderr.write("Decoder Warning: mode=%d is not valid, using mode=0\n" %mode)
776 776
777 777 if times != None:
778 778 sys.stderr.write("Decoder Warning: Argument 'times' in not used anymore\n")
779 779
780 780 if self.code is None:
781 781 print "Fail decoding: Code is not defined."
782 782 return
783 783
784 784 self.__nProfiles = dataOut.nProfiles
785 785 datadec = None
786 786
787 787 if mode == 3:
788 788 mode = 0
789 789
790 790 if dataOut.flagDataAsBlock:
791 791 """
792 792 Decoding when data have been read as block,
793 793 """
794 794
795 795 if mode == 0:
796 796 datadec = self.__convolutionByBlockInTime(dataOut.data)
797 797 if mode == 1:
798 798 datadec = self.__convolutionByBlockInFreq(dataOut.data)
799 799 else:
800 800 """
801 801 Decoding when data have been read profile by profile
802 802 """
803 803 if mode == 0:
804 804 datadec = self.__convolutionInTime(dataOut.data)
805 805
806 806 if mode == 1:
807 807 datadec = self.__convolutionInFreq(dataOut.data)
808 808
809 809 if mode == 2:
810 810 datadec = self.__convolutionInFreqOpt(dataOut.data)
811 811
812 812 if datadec is None:
813 813 raise ValueError, "Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode
814 814
815 815 dataOut.code = self.code
816 816 dataOut.nCode = self.nCode
817 817 dataOut.nBaud = self.nBaud
818 818
819 819 dataOut.data = datadec
820 820
821 821 dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
822 822
823 823 dataOut.flagDecodeData = True #asumo q la data esta decodificada
824 824
825 825 if self.__profIndex == self.nCode-1:
826 826 self.__profIndex = 0
827 827 return 1
828 828
829 829 self.__profIndex += 1
830 830
831 831 return 1
832 832 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
833 833
834 834
835 835 class ProfileConcat(Operation):
836 836
837 837 isConfig = False
838 838 buffer = None
839 839 concat_m =None
840 840
841 841 def __init__(self, **kwargs):
842 842
843 843 Operation.__init__(self, **kwargs)
844 844 self.profileIndex = 0
845 845
846 846 def reset(self):
847 847 self.buffer = numpy.zeros_like(self.buffer)
848 848 self.start_index = 0
849 849 self.times = 1
850 850
851 851 def setup(self, data, m, n=1):
852 852 self.buffer = numpy.zeros((data.shape[0],data.shape[1]*m),dtype=type(data[0,0]))
853 853 self.nHeights = data.shape[1]#.nHeights
854 854 self.start_index = 0
855 855 self.times = 1
856 856
857 857 def concat(self, data):
858 858
859 859 self.buffer[:,self.start_index:self.nHeights*self.times] = data.copy()
860 860 self.start_index = self.start_index + self.nHeights
861 861
862 862 def run(self, dataOut, m):
863 863
864 864 self.concat_m= m
865 865 dataOut.flagNoData = True
866 866
867 867 if not self.isConfig:
868 868 self.setup(dataOut.data, m, 1)
869 869 self.isConfig = True
870 870
871 871 if dataOut.flagDataAsBlock:
872 872 raise ValueError, "ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False"
873 873
874 874 else:
875 875 self.concat(dataOut.data)
876 876 self.times += 1
877 877 if self.times > m:
878 878 dataOut.data = self.buffer
879 879 self.reset()
880 880 dataOut.flagNoData = False
881 881 # se deben actualizar mas propiedades del header y del objeto dataOut, por ejemplo, las alturas
882 882 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
883 883 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * m
884 884 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
885 885 dataOut.ippSeconds *= m
886 886 dataOut.concat_m = int(m)
887 887
888 888 class ProfileSelector(Operation):
889 889
890 890 profileIndex = None
891 891 # Tamanho total de los perfiles
892 892 nProfiles = None
893 893
894 894 def __init__(self, **kwargs):
895 895
896 896 Operation.__init__(self, **kwargs)
897 897 self.profileIndex = 0
898 898
899 899 def incProfileIndex(self):
900 900
901 901 self.profileIndex += 1
902 902
903 903 if self.profileIndex >= self.nProfiles:
904 904 self.profileIndex = 0
905 905
906 906 def isThisProfileInRange(self, profileIndex, minIndex, maxIndex):
907 907
908 908 if profileIndex < minIndex:
909 909 return False
910 910
911 911 if profileIndex > maxIndex:
912 912 return False
913 913
914 914 return True
915 915
916 916 def isThisProfileInList(self, profileIndex, profileList):
917 917
918 918 if profileIndex not in profileList:
919 919 return False
920 920
921 921 return True
922 922
923 923 def run(self, dataOut, profileList=None, profileRangeList=None, beam=None, byblock=False, rangeList = None, nProfiles=None):
924 924
925 925 """
926 926 ProfileSelector:
927 927
928 928 Inputs:
929 929 profileList : Index of profiles selected. Example: profileList = (0,1,2,7,8)
930 930
931 931 profileRangeList : Minimum and maximum profile indexes. Example: profileRangeList = (4, 30)
932 932
933 933 rangeList : List of profile ranges. Example: rangeList = ((4, 30), (32, 64), (128, 256))
934 934
935 935 """
936 print "HOLA MUNDO CRUEL"
936 #print "HOLA MUNDO CRUEL"
937 937 if rangeList is not None:
938 938 if type(rangeList[0]) not in (tuple, list):
939 939 rangeList = [rangeList]
940 940
941 941 dataOut.flagNoData = True
942 942
943 943 if dataOut.flagDataAsBlock:
944 944 """
945 945 data dimension = [nChannels, nProfiles, nHeis]
946 946 """
947 947 if profileList != None:
948 948 dataOut.data = dataOut.data[:,profileList,:]
949 949
950 950 if profileRangeList != None:
951 951 minIndex = profileRangeList[0]
952 952 maxIndex = profileRangeList[1]
953 953 profileList = range(minIndex, maxIndex+1)
954 954
955 955 dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
956 956
957 957 if rangeList != None:
958 958
959 959 profileList = []
960 960
961 961 for thisRange in rangeList:
962 962 minIndex = thisRange[0]
963 963 maxIndex = thisRange[1]
964 964
965 965 profileList.extend(range(minIndex, maxIndex+1))
966 966
967 967 dataOut.data = dataOut.data[:,profileList,:]
968 968
969 969 dataOut.nProfiles = len(profileList)
970 970 dataOut.profileIndex = dataOut.nProfiles - 1
971 971 dataOut.flagNoData = False
972 972
973 973 return True
974 974
975 975 """
976 976 data dimension = [nChannels, nHeis]
977 977 """
978 978
979 979 if profileList != None:
980 980
981 981 if self.isThisProfileInList(dataOut.profileIndex, profileList):
982 982
983 983 self.nProfiles = len(profileList)
984 984 dataOut.nProfiles = self.nProfiles
985 985 dataOut.profileIndex = self.profileIndex
986 986 dataOut.flagNoData = False
987 987
988 988 self.incProfileIndex()
989 989 return True
990 990
991 991 if profileRangeList != None:
992 992
993 993 minIndex = profileRangeList[0]
994 994 maxIndex = profileRangeList[1]
995 995
996 996 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
997 997
998 998 self.nProfiles = maxIndex - minIndex + 1
999 999 dataOut.nProfiles = self.nProfiles
1000 1000 dataOut.profileIndex = self.profileIndex
1001 1001 dataOut.flagNoData = False
1002 1002
1003 1003 self.incProfileIndex()
1004 1004 return True
1005 1005
1006 1006 if rangeList != None:
1007 1007
1008 1008 nProfiles = 0
1009 1009
1010 1010 for thisRange in rangeList:
1011 1011 minIndex = thisRange[0]
1012 1012 maxIndex = thisRange[1]
1013 1013
1014 1014 nProfiles += maxIndex - minIndex + 1
1015 1015
1016 1016 for thisRange in rangeList:
1017 1017
1018 1018 minIndex = thisRange[0]
1019 1019 maxIndex = thisRange[1]
1020 1020
1021 1021 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
1022 1022
1023 1023 self.nProfiles = nProfiles
1024 1024 dataOut.nProfiles = self.nProfiles
1025 1025 dataOut.profileIndex = self.profileIndex
1026 1026 dataOut.flagNoData = False
1027 1027
1028 1028 self.incProfileIndex()
1029 1029
1030 1030 break
1031 1031
1032 1032 return True
1033 1033
1034 1034
1035 1035 if beam != None: #beam is only for AMISR data
1036 1036 if self.isThisProfileInList(dataOut.profileIndex, dataOut.beamRangeDict[beam]):
1037 1037 dataOut.flagNoData = False
1038 1038 dataOut.profileIndex = self.profileIndex
1039 1039
1040 1040 self.incProfileIndex()
1041 1041
1042 1042 return True
1043 1043
1044 1044 raise ValueError, "ProfileSelector needs profileList, profileRangeList or rangeList parameter"
1045 1045
1046 1046 return False
1047 1047
1048 1048 class Reshaper(Operation):
1049 1049
1050 1050 def __init__(self, **kwargs):
1051 1051
1052 1052 Operation.__init__(self, **kwargs)
1053 1053
1054 1054 self.__buffer = None
1055 1055 self.__nitems = 0
1056 1056
1057 1057 def __appendProfile(self, dataOut, nTxs):
1058 1058
1059 1059 if self.__buffer is None:
1060 1060 shape = (dataOut.nChannels, int(dataOut.nHeights/nTxs) )
1061 1061 self.__buffer = numpy.empty(shape, dtype = dataOut.data.dtype)
1062 1062
1063 1063 ini = dataOut.nHeights * self.__nitems
1064 1064 end = ini + dataOut.nHeights
1065 1065
1066 1066 self.__buffer[:, ini:end] = dataOut.data
1067 1067
1068 1068 self.__nitems += 1
1069 1069
1070 1070 return int(self.__nitems*nTxs)
1071 1071
1072 1072 def __getBuffer(self):
1073 1073
1074 1074 if self.__nitems == int(1./self.__nTxs):
1075 1075
1076 1076 self.__nitems = 0
1077 1077
1078 1078 return self.__buffer.copy()
1079 1079
1080 1080 return None
1081 1081
1082 1082 def __checkInputs(self, dataOut, shape, nTxs):
1083 1083
1084 1084 if shape is None and nTxs is None:
1085 1085 raise ValueError, "Reshaper: shape of factor should be defined"
1086 1086
1087 1087 if nTxs:
1088 1088 if nTxs < 0:
1089 1089 raise ValueError, "nTxs should be greater than 0"
1090 1090
1091 1091 if nTxs < 1 and dataOut.nProfiles % (1./nTxs) != 0:
1092 1092 raise ValueError, "nProfiles= %d is not divisibled by (1./nTxs) = %f" %(dataOut.nProfiles, (1./nTxs))
1093 1093
1094 1094 shape = [dataOut.nChannels, dataOut.nProfiles*nTxs, dataOut.nHeights/nTxs]
1095 1095
1096 1096 return shape, nTxs
1097 1097
1098 1098 if len(shape) != 2 and len(shape) != 3:
1099 1099 raise ValueError, "shape dimension should be equal to 2 or 3. shape = (nProfiles, nHeis) or (nChannels, nProfiles, nHeis). Actually shape = (%d, %d, %d)" %(dataOut.nChannels, dataOut.nProfiles, dataOut.nHeights)
1100 1100
1101 1101 if len(shape) == 2:
1102 1102 shape_tuple = [dataOut.nChannels]
1103 1103 shape_tuple.extend(shape)
1104 1104 else:
1105 1105 shape_tuple = list(shape)
1106 1106
1107 1107 nTxs = 1.0*shape_tuple[1]/dataOut.nProfiles
1108 1108
1109 1109 return shape_tuple, nTxs
1110 1110
1111 1111 def run(self, dataOut, shape=None, nTxs=None):
1112 1112
1113 1113 shape_tuple, self.__nTxs = self.__checkInputs(dataOut, shape, nTxs)
1114 1114
1115 1115 dataOut.flagNoData = True
1116 1116 profileIndex = None
1117 1117
1118 1118 if dataOut.flagDataAsBlock:
1119 1119
1120 1120 dataOut.data = numpy.reshape(dataOut.data, shape_tuple)
1121 1121 dataOut.flagNoData = False
1122 1122
1123 1123 profileIndex = int(dataOut.nProfiles*self.__nTxs) - 1
1124 1124
1125 1125 else:
1126 1126
1127 1127 if self.__nTxs < 1:
1128 1128
1129 1129 self.__appendProfile(dataOut, self.__nTxs)
1130 1130 new_data = self.__getBuffer()
1131 1131
1132 1132 if new_data is not None:
1133 1133 dataOut.data = new_data
1134 1134 dataOut.flagNoData = False
1135 1135
1136 1136 profileIndex = dataOut.profileIndex*nTxs
1137 1137
1138 1138 else:
1139 1139 raise ValueError, "nTxs should be greater than 0 and lower than 1, or use VoltageReader(..., getblock=True)"
1140 1140
1141 1141 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1142 1142
1143 1143 dataOut.heightList = numpy.arange(dataOut.nHeights/self.__nTxs) * deltaHeight + dataOut.heightList[0]
1144 1144
1145 1145 dataOut.nProfiles = int(dataOut.nProfiles*self.__nTxs)
1146 1146
1147 1147 dataOut.profileIndex = profileIndex
1148 1148
1149 1149 dataOut.ippSeconds /= self.__nTxs
1150 1150
1151 1151 class SplitProfiles(Operation):
1152 1152
1153 1153 def __init__(self, **kwargs):
1154 1154
1155 1155 Operation.__init__(self, **kwargs)
1156 1156
1157 1157 def run(self, dataOut, n):
1158 1158
1159 1159 dataOut.flagNoData = True
1160 1160 profileIndex = None
1161 1161
1162 1162 if dataOut.flagDataAsBlock:
1163 1163
1164 1164 #nchannels, nprofiles, nsamples
1165 1165 shape = dataOut.data.shape
1166 1166
1167 1167 if shape[2] % n != 0:
1168 1168 raise ValueError, "Could not split the data, n=%d has to be multiple of %d" %(n, shape[2])
1169 1169
1170 1170 new_shape = shape[0], shape[1]*n, shape[2]/n
1171 1171
1172 1172 dataOut.data = numpy.reshape(dataOut.data, new_shape)
1173 1173 dataOut.flagNoData = False
1174 1174
1175 1175 profileIndex = int(dataOut.nProfiles/n) - 1
1176 1176
1177 1177 else:
1178 1178
1179 1179 raise ValueError, "Could not split the data when is read Profile by Profile. Use VoltageReader(..., getblock=True)"
1180 1180
1181 1181 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1182 1182
1183 1183 dataOut.heightList = numpy.arange(dataOut.nHeights/n) * deltaHeight + dataOut.heightList[0]
1184 1184
1185 1185 dataOut.nProfiles = int(dataOut.nProfiles*n)
1186 1186
1187 1187 dataOut.profileIndex = profileIndex
1188 1188
1189 1189 dataOut.ippSeconds /= n
1190 1190
1191 1191 class CombineProfiles(Operation):
1192 1192
1193 1193 def __init__(self, **kwargs):
1194 1194
1195 1195 Operation.__init__(self, **kwargs)
1196 1196
1197 1197 self.__remData = None
1198 1198 self.__profileIndex = 0
1199 1199
1200 1200 def run(self, dataOut, n):
1201 1201
1202 1202 dataOut.flagNoData = True
1203 1203 profileIndex = None
1204 1204
1205 1205 if dataOut.flagDataAsBlock:
1206 1206
1207 1207 #nchannels, nprofiles, nsamples
1208 1208 shape = dataOut.data.shape
1209 1209 new_shape = shape[0], shape[1]/n, shape[2]*n
1210 1210
1211 1211 if shape[1] % n != 0:
1212 1212 raise ValueError, "Could not split the data, n=%d has to be multiple of %d" %(n, shape[1])
1213 1213
1214 1214 dataOut.data = numpy.reshape(dataOut.data, new_shape)
1215 1215 dataOut.flagNoData = False
1216 1216
1217 1217 profileIndex = int(dataOut.nProfiles*n) - 1
1218 1218
1219 1219 else:
1220 1220
1221 1221 #nchannels, nsamples
1222 1222 if self.__remData is None:
1223 1223 newData = dataOut.data
1224 1224 else:
1225 1225 newData = numpy.concatenate((self.__remData, dataOut.data), axis=1)
1226 1226
1227 1227 self.__profileIndex += 1
1228 1228
1229 1229 if self.__profileIndex < n:
1230 1230 self.__remData = newData
1231 1231 #continue
1232 1232 return
1233 1233
1234 1234 self.__profileIndex = 0
1235 1235 self.__remData = None
1236 1236
1237 1237 dataOut.data = newData
1238 1238 dataOut.flagNoData = False
1239 1239
1240 1240 profileIndex = dataOut.profileIndex/n
1241 1241
1242 1242
1243 1243 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1244 1244
1245 1245 dataOut.heightList = numpy.arange(dataOut.nHeights*n) * deltaHeight + dataOut.heightList[0]
1246 1246
1247 1247 dataOut.nProfiles = int(dataOut.nProfiles/n)
1248 1248
1249 1249 dataOut.profileIndex = profileIndex
1250 1250
1251 1251 dataOut.ippSeconds *= n
1252 1252
1253 1253
1254 1254 class SSheightProfiles(Operation):
1255 1255
1256 1256 step = None
1257 1257 nsamples = None
1258 1258 bufferShape = None
1259 1259 profileShape = None
1260 1260 sshProfiles = None
1261 1261 profileIndex = None
1262 1262
1263 1263 def __init__(self, **kwargs):
1264 1264
1265 1265 Operation.__init__(self, **kwargs)
1266 1266 self.isConfig = False
1267 1267
1268 1268 def setup(self,dataOut ,step = None , nsamples = None):
1269 1269
1270 1270 if step == None and nsamples == None:
1271 1271 raise ValueError, "step or nheights should be specified ..."
1272 1272
1273 1273 self.step = step
1274 1274 self.nsamples = nsamples
1275 1275 self.__nChannels = dataOut.nChannels
1276 1276 self.__nProfiles = dataOut.nProfiles
1277 1277 self.__nHeis = dataOut.nHeights
1278 1278 shape = dataOut.data.shape #nchannels, nprofiles, nsamples
1279 1279 print "input nChannels",self.__nChannels
1280 1280 print "input nProfiles",self.__nProfiles
1281 1281 print "input nHeis",self.__nHeis
1282 1282 print "input Shape",shape
1283 1283
1284 1284
1285 1285
1286 1286 residue = (shape[1] - self.nsamples) % self.step
1287 1287 if residue != 0:
1288 1288 print "The residue is %d, step=%d should be multiple of %d to avoid loss of %d samples"%(residue,step,shape[1] - self.nsamples,residue)
1289 1289
1290 1290 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1291 1291 numberProfile = self.nsamples
1292 1292 numberSamples = (shape[1] - self.nsamples)/self.step
1293 1293
1294 1294 print "new numberProfile",numberProfile
1295 1295 print "new numberSamples",numberSamples
1296 1296
1297 1297 print "New number of profile: %d, number of height: %d, Resolution %f Km"%(numberProfile,numberSamples,deltaHeight*self.step)
1298 1298
1299 1299 self.bufferShape = shape[0], numberSamples, numberProfile # nchannels, nsamples , nprofiles
1300 1300 self.profileShape = shape[0], numberProfile, numberSamples # nchannels, nprofiles, nsamples
1301 1301
1302 1302 self.buffer = numpy.zeros(self.bufferShape , dtype=numpy.complex)
1303 1303 self.sshProfiles = numpy.zeros(self.profileShape, dtype=numpy.complex)
1304 1304
1305 1305 def run(self, dataOut, step, nsamples):
1306 1306
1307 1307 dataOut.flagNoData = True
1308 1308 dataOut.flagDataAsBlock = False
1309 1309 profileIndex = None
1310 1310
1311 1311
1312 1312 if not self.isConfig:
1313 1313 self.setup(dataOut, step=step , nsamples=nsamples)
1314 1314 self.isConfig = True
1315 1315
1316 1316 for i in range(self.buffer.shape[1]):
1317 1317 #self.buffer[:,i] = numpy.flip(dataOut.data[:,i*self.step:i*self.step + self.nsamples])
1318 1318 self.buffer[:,i] = dataOut.data[:,i*self.step:i*self.step + self.nsamples]
1319 1319 #self.buffer[:,j,self.__nHeis-j*self.step - self.nheights:self.__nHeis-j*self.step] = numpy.flip(dataOut.data[:,j*self.step:j*self.step + self.nheights])
1320 1320
1321 1321 for j in range(self.buffer.shape[0]):
1322 1322 self.sshProfiles[j] = numpy.transpose(self.buffer[j])
1323 1323
1324 1324 profileIndex = self.nsamples
1325 1325 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1326 1326 ippSeconds = (deltaHeight*1.0e-6)/(0.15)
1327 1327 #print "ippSeconds",ippSeconds
1328 1328 try:
1329 1329 if dataOut.concat_m is not None:
1330 1330 ippSeconds= ippSeconds/float(dataOut.concat_m)
1331 1331 #print "Profile concat %d"%dataOut.concat_m
1332 1332 except:
1333 1333 pass
1334 1334
1335 1335 dataOut.data = self.sshProfiles
1336 1336 dataOut.flagNoData = False
1337 1337 dataOut.heightList = numpy.arange(self.buffer.shape[1]) *self.step*deltaHeight + dataOut.heightList[0]
1338 1338 dataOut.nProfiles = int(dataOut.nProfiles*self.nsamples)
1339 1339 dataOut.profileIndex = profileIndex
1340 1340 dataOut.flagDataAsBlock = True
1341 1341 dataOut.ippSeconds = ippSeconds
1342 1342 dataOut.step = self.step
1343 1343
1344 1344 class voltACFLags(Operation):
1345 1345
1346 1346 data_acf = None
1347 1347 lags = None
1348 1348 mode = None
1349 1349 fullBuffer = None
1350 1350 pairsList = None
1351 1351 tmp = None
1352 1352
1353 1353 def __init__(self, **kwargs):
1354 1354 Operation.__init__(self, **kwargs)
1355 1355 self.isConfig = False
1356 1356 self.profIndex = 0
1357 1357 self.buffer = None
1358 self.channelList = []
1358 1359
1359 1360
1360 1361 def setup(self,dataOut ,lags = None,mode =None, fullBuffer= None ,pairsList = None,nAvg = 1):
1361 1362
1362 1363 self.lags = lags
1363 1364 print self.lags
1364 1365 self.mode = mode
1365 1366 self.fullBuffer= fullBuffer
1366 1367 self.nAvg = nAvg
1367 self.pairsList = pairsList
1368 self.pairsList = [pairsList]
1368 1369 nChannels = dataOut.nChannels
1369 1370 nProfiles = dataOut.nProfiles
1370 1371 nHeights = dataOut.nHeights
1371 1372 self.__nProfiles = dataOut.nProfiles
1372 1373 self.__nHeis = dataOut.nHeights
1373 1374
1374 1375 if mode == 'time':
1375 1376 print "Mode lags equal time for default."
1376 1377 else:
1377 1378 print "Mode lags equal height."
1378 1379
1379 1380 if pairsList == None:
1380 1381 print "Pairs list selected by default (1,0)"
1381 1382 pairsList = [(0,1)]
1382 1383 self.pairsList= pairsList
1383 1384
1384 self.selectChannels(self.pairsList)
1385
1386 for i in range(len(self.pairsList)):
1387 self.channelList.append(self.pairsList[i][0])
1388 self.channelList.append(self.pairsList[i][1])
1385 1389
1386 1390 if lags == None:
1387 1391 if mode=='time':
1388 1392 self.lags = numpy.arange(0,nProfiles)# -nProfiles+1, nProfiles
1389 1393 print "self.lags", len(self.lags)
1390 1394 if mode=='height':
1391 1395 self.lags = numpy.arange(0,nHeights)# -nHeights+1, nHeights
1392 1396
1393 1397 # buffer de canalaes, perfiles, alturas
1394 1398 if self.buffer is None:
1395 self.buffer = numpy.zeros((len(pairsList),nProfiles,nHeights),dtype='complex')
1399 self.buffer = numpy.zeros((nChannels,nProfiles,nHeights),dtype='complex')
1396 1400
1397 1401 if fullBuffer:
1398 self.tmp = numpy.zeros((len(pairsList), len(self.lags), nProfiles, nHeights), dtype = 'complex')*numpy.nan
1402 self.tmp = numpy.zeros((len(self.pairsList), len(self.lags), nProfiles, nHeights), dtype = 'complex')*numpy.nan
1399 1403 elif mode =='time':
1400 self.tmp = numpy.zeros((len(pairsList), len(self.lags), nHeights),dtype='complex')
1404 self.tmp = numpy.zeros((len(self.pairsList), len(self.lags), nHeights),dtype='complex')
1401 1405 elif mode =='height':
1402 self.tmp = numpy.zeros(len(pairsList), (len(self.lags), nProfiles),dtype='complex')
1406 self.tmp = numpy.zeros((len(self.pairsList), len(self.lags), nProfiles),dtype='complex')
1403 1407
1404 1408 print "lags", len(self.lags),self.lags
1405 1409 print "mode",self.mode
1406 1410 print "nChannels", nChannels
1407 1411 print "nProfiles", nProfiles
1408 1412 print "nHeights" , nHeights
1413 print "acf_channels",len(self.pairsList)
1414 print "channelList",self.channelList
1409 1415 print "pairsList", pairsList,len(self.pairsList)
1410 1416 print "fullBuffer", fullBuffer
1411 1417 #print "type(pairsList)",type(pairsList)
1412 1418 print "tmp.shape",self.tmp.shape
1413 1419
1414 1420
1415 1421 def run(self, dataOut, lags =None,mode ='time',fullBuffer= False ,pairsList = None,nAvg = 1):
1416 1422
1417 1423 dataOut.flagNoData = True
1418 1424
1419 1425 if not self.isConfig:
1420 1426 self.setup(dataOut, lags = lags,mode = mode, fullBuffer= fullBuffer ,pairsList = pairsList,nAvg=nAvg)
1421 1427 self.isConfig = True
1422 print "pairsList Ale", self.pairsList
1423 print dataOut.data[pairsList,:].shape
1428
1424 1429 if dataOut.type == "Voltage":
1425 1430 if dataOut.flagDataAsBlock:
1426 1431 print "Not implemented yet"
1427 1432 return 0
1428 1433 else:
1429 print "shapebuffer",self.buffer[:,0,:].shape
1430 self.buffer[:, self.profIndex, :] = dataOut.data#error
1434 self.buffer[:, self.profIndex, :] = dataOut.data
1431 1435 self.profIndex += 1
1432 1436
1433 1437 if self.profIndex == self.__nProfiles :
1438
1434 1439 data_pre = self.buffer #data
1435 print "size",data_pre.shape
1436 # Here is the loop :D
1437 1440 for l in range(len(self.pairsList)):
1438 1441 ch0 = self.pairsList[l][0]
1439 1442 ch1 = self.pairsList[l][1]
1440 1443 for i in range(len(self.lags)):
1441 1444 idx = self.lags[i]
1442 1445 if self.mode == 'time':
1443 1446 acf0 = data_pre[ch0,:self.__nProfiles-idx,:]*numpy.conj(data_pre[ch1,idx:,:]) # pair,lag,height
1444 1447 else:
1445 1448 acf0 = data_pre[ch0,:,:self.__nHeights-idx]*numpy.conj(data_pre[ch1,:,idx:]) # pair,lag,profile
1446 1449
1447 1450 if self.fullBuffer:
1448 1451 self.tmp[l,i,:acf0.shape[0],:]= acf0
1449 1452 else:
1450 1453 self.tmp[l,i,:]= numpy.sum(acf0,axis=0)
1451 1454 if self.fullBuffer:
1452 1455 self.tmp = numpy.sum(numpy.reshape(self.tmp,(self.tmp.shape[0],self.tmp.shape[1],self.tmp.shape[2]/self.nAvg,self.nAvg,self.tmp.shape[3])),axis=3)
1453 1456 dataOut.nAvg = self.nAvg
1454
1455 1457 if self.mode == 'time':
1458 #print "entre"
1456 1459 delta = dataOut.ippSeconds*dataOut.nCohInt
1457 1460 else:
1458 1461 delta = dataOut.heightList[1] - dataOut.heightList[0]
1459 1462
1460 shape= self.tmp.shape # mode time
1461 # Normalizando
1462 for i in range(len(pairsList)):
1463 shape= self.tmp.shape
1464 for i in range(len(self.pairsList)):
1463 1465 for j in range(shape[2]):
1464 1466 self.tmp[i,:,j]= self.tmp[i,:,j].real / numpy.max(numpy.abs(self.tmp[i,:,j]))
1465 1467
1466 1468 #import matplotlib.pyplot as plt
1467 1469 #print "test",self.tmp.shape
1468 1470 #print self.tmp[0,0,0]
1469 1471 #print numpy.max(numpy.abs(self.tmp[0,:,0]))
1470 1472 #acf_tmp=self.tmp[0,:,100].real/numpy.max(numpy.abs(self.tmp[0,:,100]))
1471 1473 #print acf_tmp
1472 1474 #plt.plot(acf_tmp)
1473 1475 #plt.show()
1474 1476 #import time
1475 1477 #time.sleep(20)
1476 dataOut.data = self.tmp
1478 dataOut.data = self.buffer
1479 dataOut.data_acfLag = self.tmp
1477 1480 dataOut.mode = self.mode
1478 1481 dataOut.nLags = len(self.lags)
1479 1482 dataOut.nProfiles = len(self.lags)
1480 1483 dataOut.pairsList = pairsList
1481 1484 dataOut.nPairs = len(pairsList)
1482 1485 dataOut.lagRange = numpy.array(self.lags)*delta
1483 1486 dataOut.flagDataAsBlock = True
1484 1487 dataOut.flagNoData = False
1488 self.profIndex = 0
1485 1489
1486 1490
1487 1491 import time
1488 1492 #################################################
1489 1493
1490 1494 class decoPseudorandom(Operation):
1491 1495
1492 1496 nProfiles= 0
1493 1497 buffer= None
1494 1498 isConfig = False
1495 1499
1496 1500 def setup(self, clen= 10000,seed= 0,Nranges= 1000,oversample=1):
1497 1501 #code = create_pseudo_random_code(clen=clen, seed=seed)
1498 1502 code= rep_seq(create_pseudo_random_code(clen=clen, seed=seed),rep=oversample)
1499 1503 #print ("code_rx", code.shape)
1500 1504 #N = int(an_len/clen) # 100
1501 1505 B_cache = 0
1502 1506 r_cache = 0
1503 1507 B_cached = False
1504 1508 r = create_estimation_matrix(code=code, cache=True, rmax=Nranges)
1505 1509 #print ("code shape", code.shape)
1506 1510 #print ("seed",seed)
1507 1511 #print ("Code", code[0:10])
1508 1512 self.B = r['B']
1509 1513
1510 1514
1511 1515 def run (self,dataOut,length_code= 10000,seed= 0,Nranges= 1000,oversample=1):
1512 1516 #print((dataOut.data.shape))
1513 1517 if not self.isConfig:
1514 1518 self.setup(clen= length_code,seed= seed,Nranges= Nranges,oversample=oversample)
1515 1519 self.isConfig = True
1516 1520
1517 1521 dataOut.flagNoData = True
1518 1522 data =dataOut.data
1519 1523 #print "length_CODE",length_code
1520 1524 data_shape = (data.shape[1])
1521 1525 #print "data_shape",data_shape
1522 1526 n = (length_code /data_shape)
1523 1527 #print "we need this number of sample",n
1524 1528
1525 1529 if n>0 and self.buffer is None:
1526 1530 self.buffer = numpy.zeros([1, length_code], dtype=numpy.complex64)
1527 1531 self.buffer[0][0:data_shape] = data[0]
1528 1532 #print "FIRST CREATION",self.buffer.shape
1529 1533
1530 1534 else:
1531 1535 self.buffer[0][self.nProfiles*data_shape:(self.nProfiles+1)*data_shape]=data[0]
1532 1536
1533 1537 #print "buffer_shape",(self.buffer.shape)
1534 1538 self.nProfiles += 1
1535 1539 #print "count",self.nProfiles
1536 1540
1537 1541 if self.nProfiles== n:
1538 1542 temporal = numpy.dot(self.B, numpy.transpose(self.buffer))
1539 1543 #print temporal.shape
1540 1544 #import time
1541 1545 #time.sleep(40)
1542 1546 dataOut.data=numpy.transpose(temporal)
1543 1547
1544 1548 dataOut.flagNoData = False
1545 1549 self.buffer= None
1546 1550 self.nProfiles = 0
1547 1551
1548 1552 # import collections
1549 1553 # from scipy.stats import mode
1550 1554 #
1551 1555 # class Synchronize(Operation):
1552 1556 #
1553 1557 # isConfig = False
1554 1558 # __profIndex = 0
1555 1559 #
1556 1560 # def __init__(self, **kwargs):
1557 1561 #
1558 1562 # Operation.__init__(self, **kwargs)
1559 1563 # # self.isConfig = False
1560 1564 # self.__powBuffer = None
1561 1565 # self.__startIndex = 0
1562 1566 # self.__pulseFound = False
1563 1567 #
1564 1568 # def __findTxPulse(self, dataOut, channel=0, pulse_with = None):
1565 1569 #
1566 1570 # #Read data
1567 1571 #
1568 1572 # powerdB = dataOut.getPower(channel = channel)
1569 1573 # noisedB = dataOut.getNoise(channel = channel)[0]
1570 1574 #
1571 1575 # self.__powBuffer.extend(powerdB.flatten())
1572 1576 #
1573 1577 # dataArray = numpy.array(self.__powBuffer)
1574 1578 #
1575 1579 # filteredPower = numpy.correlate(dataArray, dataArray[0:self.__nSamples], "same")
1576 1580 #
1577 1581 # maxValue = numpy.nanmax(filteredPower)
1578 1582 #
1579 1583 # if maxValue < noisedB + 10:
1580 1584 # #No se encuentra ningun pulso de transmision
1581 1585 # return None
1582 1586 #
1583 1587 # maxValuesIndex = numpy.where(filteredPower > maxValue - 0.1*abs(maxValue))[0]
1584 1588 #
1585 1589 # if len(maxValuesIndex) < 2:
1586 1590 # #Solo se encontro un solo pulso de transmision de un baudio, esperando por el siguiente TX
1587 1591 # return None
1588 1592 #
1589 1593 # phasedMaxValuesIndex = maxValuesIndex - self.__nSamples
1590 1594 #
1591 1595 # #Seleccionar solo valores con un espaciamiento de nSamples
1592 1596 # pulseIndex = numpy.intersect1d(maxValuesIndex, phasedMaxValuesIndex)
1593 1597 #
1594 1598 # if len(pulseIndex) < 2:
1595 1599 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1596 1600 # return None
1597 1601 #
1598 1602 # spacing = pulseIndex[1:] - pulseIndex[:-1]
1599 1603 #
1600 1604 # #remover senales que se distancien menos de 10 unidades o muestras
1601 1605 # #(No deberian existir IPP menor a 10 unidades)
1602 1606 #
1603 1607 # realIndex = numpy.where(spacing > 10 )[0]
1604 1608 #
1605 1609 # if len(realIndex) < 2:
1606 1610 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1607 1611 # return None
1608 1612 #
1609 1613 # #Eliminar pulsos anchos (deja solo la diferencia entre IPPs)
1610 1614 # realPulseIndex = pulseIndex[realIndex]
1611 1615 #
1612 1616 # period = mode(realPulseIndex[1:] - realPulseIndex[:-1])[0][0]
1613 1617 #
1614 1618 # print "IPP = %d samples" %period
1615 1619 #
1616 1620 # self.__newNSamples = dataOut.nHeights #int(period)
1617 1621 # self.__startIndex = int(realPulseIndex[0])
1618 1622 #
1619 1623 # return 1
1620 1624 #
1621 1625 #
1622 1626 # def setup(self, nSamples, nChannels, buffer_size = 4):
1623 1627 #
1624 1628 # self.__powBuffer = collections.deque(numpy.zeros( buffer_size*nSamples,dtype=numpy.float),
1625 1629 # maxlen = buffer_size*nSamples)
1626 1630 #
1627 1631 # bufferList = []
1628 1632 #
1629 1633 # for i in range(nChannels):
1630 1634 # bufferByChannel = collections.deque(numpy.zeros( buffer_size*nSamples, dtype=numpy.complex) + numpy.NAN,
1631 1635 # maxlen = buffer_size*nSamples)
1632 1636 #
1633 1637 # bufferList.append(bufferByChannel)
1634 1638 #
1635 1639 # self.__nSamples = nSamples
1636 1640 # self.__nChannels = nChannels
1637 1641 # self.__bufferList = bufferList
1638 1642 #
1639 1643 # def run(self, dataOut, channel = 0):
1640 1644 #
1641 1645 # if not self.isConfig:
1642 1646 # nSamples = dataOut.nHeights
1643 1647 # nChannels = dataOut.nChannels
1644 1648 # self.setup(nSamples, nChannels)
1645 1649 # self.isConfig = True
1646 1650 #
1647 1651 # #Append new data to internal buffer
1648 1652 # for thisChannel in range(self.__nChannels):
1649 1653 # bufferByChannel = self.__bufferList[thisChannel]
1650 1654 # bufferByChannel.extend(dataOut.data[thisChannel])
1651 1655 #
1652 1656 # if self.__pulseFound:
1653 1657 # self.__startIndex -= self.__nSamples
1654 1658 #
1655 1659 # #Finding Tx Pulse
1656 1660 # if not self.__pulseFound:
1657 1661 # indexFound = self.__findTxPulse(dataOut, channel)
1658 1662 #
1659 1663 # if indexFound == None:
1660 1664 # dataOut.flagNoData = True
1661 1665 # return
1662 1666 #
1663 1667 # self.__arrayBuffer = numpy.zeros((self.__nChannels, self.__newNSamples), dtype = numpy.complex)
1664 1668 # self.__pulseFound = True
1665 1669 # self.__startIndex = indexFound
1666 1670 #
1667 1671 # #If pulse was found ...
1668 1672 # for thisChannel in range(self.__nChannels):
1669 1673 # bufferByChannel = self.__bufferList[thisChannel]
1670 1674 # #print self.__startIndex
1671 1675 # x = numpy.array(bufferByChannel)
1672 1676 # self.__arrayBuffer[thisChannel] = x[self.__startIndex:self.__startIndex+self.__newNSamples]
1673 1677 #
1674 1678 # deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1675 1679 # dataOut.heightList = numpy.arange(self.__newNSamples)*deltaHeight
1676 1680 # # dataOut.ippSeconds = (self.__newNSamples / deltaHeight)/1e6
1677 1681 #
1678 1682 # dataOut.data = self.__arrayBuffer
1679 1683 #
1680 1684 # self.__startIndex += self.__newNSamples
1681 1685 #
1682 1686 # return
General Comments 0
You need to be logged in to leave comments. Login now