|
|
1 | NO CONTENT: modified file |
| @@ -230,6 +230,226 class SpectraPlot_(Figure): | |||
|
|
230 | 230 | return dataOut |
|
|
231 | 231 | |
|
|
232 | 232 | @MPDecorator |
|
|
233 | class WpowerPlot_(Figure): | |
|
|
234 | ||
|
|
235 | isConfig = None | |
|
|
236 | __nsubplots = None | |
|
|
237 | ||
|
|
238 | WIDTHPROF = None | |
|
|
239 | HEIGHTPROF = None | |
|
|
240 | PREFIX = 'wpo' | |
|
|
241 | ||
|
|
242 | def __init__(self): | |
|
|
243 | Figure.__init__(self) | |
|
|
244 | self.isConfig = False | |
|
|
245 | self.__nsubplots = 1 | |
|
|
246 | self.WIDTH = 250 | |
|
|
247 | self.HEIGHT = 250 | |
|
|
248 | self.WIDTHPROF = 120 | |
|
|
249 | self.HEIGHTPROF = 0 | |
|
|
250 | self.counter_imagwr = 0 | |
|
|
251 | ||
|
|
252 | self.PLOT_CODE = WPO_CODE | |
|
|
253 | ||
|
|
254 | self.FTP_WEI = None | |
|
|
255 | self.EXP_CODE = None | |
|
|
256 | self.SUB_EXP_CODE = None | |
|
|
257 | self.PLOT_POS = None | |
|
|
258 | ||
|
|
259 | self.__xfilter_ena = False | |
|
|
260 | self.__yfilter_ena = False | |
|
|
261 | ||
|
|
262 | self.indice=1 | |
|
|
263 | ||
|
|
264 | def getSubplots(self): | |
|
|
265 | ||
|
|
266 | ncol = int(numpy.sqrt(self.nplots)+0.9) | |
|
|
267 | nrow = int(self.nplots*1./ncol + 0.9) | |
|
|
268 | ||
|
|
269 | return nrow, ncol | |
|
|
270 | ||
|
|
271 | def setup(self, id, nplots, wintitle, showprofile=True, show=True): | |
|
|
272 | ||
|
|
273 | self.__showprofile = showprofile | |
|
|
274 | self.nplots = nplots | |
|
|
275 | ||
|
|
276 | ncolspan = 1 | |
|
|
277 | colspan = 1 | |
|
|
278 | if showprofile: | |
|
|
279 | ncolspan = 3 | |
|
|
280 | colspan = 2 | |
|
|
281 | self.__nsubplots = 2 | |
|
|
282 | ||
|
|
283 | self.createFigure(id = id, | |
|
|
284 | wintitle = wintitle, | |
|
|
285 | widthplot = self.WIDTH + self.WIDTHPROF, | |
|
|
286 | heightplot = self.HEIGHT + self.HEIGHTPROF, | |
|
|
287 | show=show) | |
|
|
288 | ||
|
|
289 | nrow, ncol = self.getSubplots() | |
|
|
290 | ||
|
|
291 | counter = 0 | |
|
|
292 | for y in range(nrow): | |
|
|
293 | for x in range(ncol): | |
|
|
294 | ||
|
|
295 | if counter >= self.nplots: | |
|
|
296 | break | |
|
|
297 | ||
|
|
298 | self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1) | |
|
|
299 | ||
|
|
300 | if showprofile: | |
|
|
301 | self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1) | |
|
|
302 | ||
|
|
303 | counter += 1 | |
|
|
304 | ||
|
|
305 | def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True, | |
|
|
306 | xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, | |
|
|
307 | save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1, | |
|
|
308 | server=None, folder=None, username=None, password=None, | |
|
|
309 | ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False, | |
|
|
310 | xaxis="frequency", colormap='jet', normFactor=None): | |
|
|
311 | ||
|
|
312 | """ | |
|
|
313 | ||
|
|
314 | Input: | |
|
|
315 | dataOut : | |
|
|
316 | id : | |
|
|
317 | wintitle : | |
|
|
318 | channelList : | |
|
|
319 | showProfile : | |
|
|
320 | xmin : None, | |
|
|
321 | xmax : None, | |
|
|
322 | ymin : None, | |
|
|
323 | ymax : None, | |
|
|
324 | zmin : None, | |
|
|
325 | zmax : None | |
|
|
326 | """ | |
|
|
327 | print("***************PLOTEO******************") | |
|
|
328 | print("DATAOUT SHAPE : ",dataOut.data.shape) | |
|
|
329 | if dataOut.flagNoData: | |
|
|
330 | return dataOut | |
|
|
331 | ||
|
|
332 | if realtime: | |
|
|
333 | if not(isRealtime(utcdatatime = dataOut.utctime)): | |
|
|
334 | print('Skipping this plot function') | |
|
|
335 | return | |
|
|
336 | ||
|
|
337 | if channelList == None: | |
|
|
338 | channelIndexList = dataOut.channelIndexList | |
|
|
339 | else: | |
|
|
340 | channelIndexList = [] | |
|
|
341 | for channel in channelList: | |
|
|
342 | if channel not in dataOut.channelList: | |
|
|
343 | raise ValueError("Channel %d is not in dataOut.channelList" %channel) | |
|
|
344 | channelIndexList.append(dataOut.channelList.index(channel)) | |
|
|
345 | ||
|
|
346 | ||
|
|
347 | print("channelIndexList",channelIndexList) | |
|
|
348 | if normFactor is None: | |
|
|
349 | factor = dataOut.normFactor | |
|
|
350 | else: | |
|
|
351 | factor = normFactor | |
|
|
352 | if xaxis == "frequency": | |
|
|
353 | x = dataOut.getFreqRange(1)/1000. | |
|
|
354 | xlabel = "Frequency (kHz)" | |
|
|
355 | ||
|
|
356 | elif xaxis == "time": | |
|
|
357 | x = dataOut.getAcfRange(1) | |
|
|
358 | xlabel = "Time (ms)" | |
|
|
359 | ||
|
|
360 | else: | |
|
|
361 | x = dataOut.getVelRange(1) | |
|
|
362 | xlabel = "Velocity (m/s)" | |
|
|
363 | ||
|
|
364 | ylabel = "Range (km)" | |
|
|
365 | ||
|
|
366 | y = dataOut.getHeiRange() | |
|
|
367 | print("factor",factor) | |
|
|
368 | ||
|
|
369 | z = dataOut.data/factor # dividido /factor | |
|
|
370 | z = numpy.where(numpy.isfinite(z), z, numpy.NAN) | |
|
|
371 | zdB = 10*numpy.log10(z) | |
|
|
372 | ||
|
|
373 | avg = numpy.average(z, axis=1) | |
|
|
374 | avgdB = 10*numpy.log10(avg) | |
|
|
375 | ||
|
|
376 | noise = dataOut.getNoise()/factor | |
|
|
377 | noisedB = 10*numpy.log10(noise) | |
|
|
378 | ||
|
|
379 | thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0]) | |
|
|
380 | title = wintitle + "Weather Power" | |
|
|
381 | ||
|
|
382 | if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)): | |
|
|
383 | title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith) | |
|
|
384 | ||
|
|
385 | if not self.isConfig: | |
|
|
386 | ||
|
|
387 | nplots = len(channelIndexList) | |
|
|
388 | ||
|
|
389 | self.setup(id=id, | |
|
|
390 | nplots=nplots, | |
|
|
391 | wintitle=wintitle, | |
|
|
392 | showprofile=showprofile, | |
|
|
393 | show=show) | |
|
|
394 | ||
|
|
395 | if xmin == None: xmin = numpy.nanmin(x) | |
|
|
396 | if xmax == None: xmax = numpy.nanmax(x) | |
|
|
397 | if ymin == None: ymin = numpy.nanmin(y) | |
|
|
398 | if ymax == None: ymax = numpy.nanmax(y) | |
|
|
399 | if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3 | |
|
|
400 | if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3 | |
|
|
401 | ||
|
|
402 | self.FTP_WEI = ftp_wei | |
|
|
403 | self.EXP_CODE = exp_code | |
|
|
404 | self.SUB_EXP_CODE = sub_exp_code | |
|
|
405 | self.PLOT_POS = plot_pos | |
|
|
406 | ||
|
|
407 | self.isConfig = True | |
|
|
408 | ||
|
|
409 | self.setWinTitle(title) | |
|
|
410 | ||
|
|
411 | for i in range(self.nplots): | |
|
|
412 | index = channelIndexList[i] | |
|
|
413 | str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S")) | |
|
|
414 | title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[index], noisedB[index], str_datetime) | |
|
|
415 | if len(dataOut.beam.codeList) != 0: | |
|
|
416 | title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[index], noisedB[index], dataOut.beam.azimuthList[index], dataOut.beam.zenithList[index], str_datetime) | |
|
|
417 | ||
|
|
418 | axes = self.axesList[i*self.__nsubplots] | |
|
|
419 | axes.pcolor(x, y, zdB[index,:,:], | |
|
|
420 | xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax, | |
|
|
421 | xlabel=xlabel, ylabel=ylabel, title=title, colormap=colormap, | |
|
|
422 | ticksize=9, cblabel='') | |
|
|
423 | ||
|
|
424 | if self.__showprofile: | |
|
|
425 | axes = self.axesList[i*self.__nsubplots +1] | |
|
|
426 | axes.pline(avgdB[index,:], y, | |
|
|
427 | xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax, | |
|
|
428 | xlabel='dB', ylabel='', title='', | |
|
|
429 | ytick_visible=False, | |
|
|
430 | grid='x') | |
|
|
431 | ||
|
|
432 | noiseline = numpy.repeat(noisedB[index], len(y)) | |
|
|
433 | axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2) | |
|
|
434 | ||
|
|
435 | self.draw() | |
|
|
436 | ||
|
|
437 | if figfile == None: | |
|
|
438 | str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S") | |
|
|
439 | name = str_datetime | |
|
|
440 | if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)): | |
|
|
441 | name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith) | |
|
|
442 | figfile = self.getFilename(name) | |
|
|
443 | ||
|
|
444 | self.save(figpath=figpath, | |
|
|
445 | figfile=figfile, | |
|
|
446 | save=save, | |
|
|
447 | ftp=ftp, | |
|
|
448 | wr_period=wr_period, | |
|
|
449 | thisDatetime=thisDatetime) | |
|
|
450 | return dataOut | |
|
|
451 | ||
|
|
452 | @MPDecorator | |
|
|
233 | 453 | class CrossSpectraPlot_(Figure): |
|
|
234 | 454 | |
|
|
235 | 455 | isConfig = None |
| @@ -112,6 +112,40 class Scope_(Figure): | |||
|
|
112 | 112 | xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, |
|
|
113 | 113 | xlabel=xlabel, ylabel=ylabel, title=title) |
|
|
114 | 114 | |
|
|
115 | def plot_weatherpower(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax): | |
|
|
116 | y = y[channelIndexList,:] | |
|
|
117 | yreal = y | |
|
|
118 | ||
|
|
119 | title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S")) | |
|
|
120 | xlabel = "Range (Km)" | |
|
|
121 | ylabel = "Intensity" | |
|
|
122 | ||
|
|
123 | if not self.isConfig: | |
|
|
124 | nplots = len(channelIndexList) | |
|
|
125 | ||
|
|
126 | self.setup(id=id, | |
|
|
127 | nplots=nplots, | |
|
|
128 | wintitle='', | |
|
|
129 | show=show) | |
|
|
130 | ||
|
|
131 | if xmin == None: xmin = numpy.nanmin(x) | |
|
|
132 | if xmax == None: xmax = numpy.nanmax(x) | |
|
|
133 | if ymin == None: ymin = numpy.nanmin(yreal) | |
|
|
134 | if ymax == None: ymax = numpy.nanmax(yreal) | |
|
|
135 | ||
|
|
136 | self.isConfig = True | |
|
|
137 | ||
|
|
138 | self.setWinTitle(title) | |
|
|
139 | ||
|
|
140 | for i in range(len(self.axesList)): | |
|
|
141 | title = "Channel %d" %(i) | |
|
|
142 | axes = self.axesList[i] | |
|
|
143 | ychannel = yreal[i,:] | |
|
|
144 | axes.pline(x, ychannel, | |
|
|
145 | xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, | |
|
|
146 | xlabel=xlabel, ylabel=ylabel, title=title) | |
|
|
147 | ||
|
|
148 | ||
|
|
115 | 149 | |
|
|
116 | 150 | def run(self, dataOut, id, wintitle="", channelList=None, |
|
|
117 | 151 | xmin=None, xmax=None, ymin=None, ymax=None, save=False, |
| @@ -143,7 +177,9 class Scope_(Figure): | |||
|
|
143 | 177 | channelIndexList.append(dataOut.channelList.index(channel)) |
|
|
144 | 178 | |
|
|
145 | 179 | thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0]) |
|
|
146 | ||
|
|
180 | ### print("***************** PLOTEO **************************") | |
|
|
181 | ### print(dataOut.nProfiles) | |
|
|
182 | ### print(dataOut.heightList.shape) | |
|
|
147 | 183 | if dataOut.flagDataAsBlock: |
|
|
148 | 184 | |
|
|
149 | 185 | for i in range(dataOut.nProfiles): |
| @@ -163,6 +199,32 class Scope_(Figure): | |||
|
|
163 | 199 | ymin, |
|
|
164 | 200 | ymax) |
|
|
165 | 201 | |
|
|
202 | if type == "weatherpower": | |
|
|
203 | self.plot_weatherpower(dataOut.heightList, | |
|
|
204 | dataOut.data[:,i,:], | |
|
|
205 | id, | |
|
|
206 | channelIndexList, | |
|
|
207 | thisDatetime, | |
|
|
208 | wintitle1, | |
|
|
209 | show, | |
|
|
210 | xmin, | |
|
|
211 | xmax, | |
|
|
212 | ymin, | |
|
|
213 | ymax) | |
|
|
214 | ||
|
|
215 | if type == "weathervelocity": | |
|
|
216 | self.plot_weatherpower(dataOut.heightList, | |
|
|
217 | dataOut.data_velocity[:,i,:], | |
|
|
218 | id, | |
|
|
219 | channelIndexList, | |
|
|
220 | thisDatetime, | |
|
|
221 | wintitle1, | |
|
|
222 | show, | |
|
|
223 | xmin, | |
|
|
224 | xmax, | |
|
|
225 | ymin, | |
|
|
226 | ymax) | |
|
|
227 | ||
|
|
166 | 228 | if type == "iq": |
|
|
167 | 229 |
self.plot_iq(dataOut.heightList, |
|
|
168 | 230 | dataOut.data[:,i,:], |
| @@ -26,3 +26,5 MOMENTS_CODE = 25 | |||
|
|
26 | 26 | PARMS_CODE = 26 |
|
|
27 | 27 | SPECFIT_CODE = 27 |
|
|
28 | 28 | EWDRIFT_CODE = 28 |
|
|
29 | ||
|
|
30 | WPO_CODE = 29 #Weather Intensity - Power | |
| @@ -869,7 +869,8 class ParamWriter(Operation): | |||
|
|
869 | 869 | dsList = self.dsList |
|
|
870 | 870 | data = self.data |
|
|
871 | 871 | ind = 0 |
|
|
872 | ||
|
|
872 | #print("dsList ",dsList) | |
|
|
873 | #print("len ",len(dsList)) | |
|
|
873 | 874 | while ind < len(dsList): |
|
|
874 | 875 | dsInfo = dsList[ind] |
|
|
875 | 876 | dataAux = getattr(self.dataOut, dsInfo['variable']) |
| @@ -902,22 +903,41 class ParamWriter(Operation): | |||
|
|
902 | 903 | dsList = self.dsList |
|
|
903 | 904 | |
|
|
904 | 905 | for i in range(len(self.ds)): |
|
|
906 | print("#############", i , "#######################") | |
|
|
905 | 907 | dsInfo = dsList[i] |
|
|
906 | 908 | nDim = dsInfo['nDim'] |
|
|
907 | 909 | mode = dsInfo['mode'] |
|
|
908 | ||
|
|
910 | print("dsInfo",dsInfo) | |
|
|
911 | print("nDim",nDim) | |
|
|
912 | print("mode",mode) | |
|
|
909 | 913 | # First time |
|
|
910 | 914 | if self.firsttime: |
|
|
915 | print("ENTRE FIRSTIME") | |
|
|
911 | 916 | if type(self.data[i]) == numpy.ndarray: |
|
|
912 | 917 | |
|
|
913 | 918 | if nDim == 3: |
|
|
919 | print("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx") | |
|
|
920 | print("ndim","dentro del primer if 3") | |
|
|
914 | 921 | self.data[i] = self.data[i].reshape((self.data[i].shape[0],self.data[i].shape[1],1)) |
|
|
922 | print(self.data[i].shape) | |
|
|
923 | print(type(self.data[i])) | |
|
|
915 | 924 | self.ds[i].resize(self.data[i].shape) |
|
|
925 | print(self.ds[i].shape) | |
|
|
926 | print(type(self.ds[i])) | |
|
|
916 | 927 | if mode == 2: |
|
|
917 | 928 | self.ds[i].resize(self.data[i].shape) |
|
|
929 | try: | |
|
|
930 | print("PTM ODIO ESTO") | |
|
|
931 | print(self.ds[i][:].shape) | |
|
|
918 | 932 | self.ds[i][:] = self.data[i] |
|
|
919 | else: | |
|
|
933 | print("*****___________********______******") | |
|
|
920 | 934 | |
|
|
935 | except: | |
|
|
936 | print("q habra pasaado") | |
|
|
937 | return | |
|
|
938 | print("LLEGUE Y CUMPLI EL IF") | |
|
|
939 | else: | |
|
|
940 | print("ELSE -----------------------") | |
|
|
921 | 941 | # From second time |
|
|
922 | 942 | # Meteors! |
|
|
923 | 943 | if mode == 2: |
| @@ -944,7 +964,8 class ParamWriter(Operation): | |||
|
|
944 | 964 | |
|
|
945 | 965 | self.firsttime = False |
|
|
946 | 966 | self.blockIndex += 1 |
|
|
947 | ||
|
|
967 | print("HOLA AMIGOS COMO ESTAN LLEGUE") | |
|
|
968 | print("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx") | |
|
|
948 | 969 | #Close to save changes |
|
|
949 | 970 | self.fp.flush() |
|
|
950 | 971 | self.fp.close() |
| @@ -1409,10 +1430,12 class ParameterWriter(Operation): | |||
|
|
1409 | 1430 | self.setNextFile() |
|
|
1410 | 1431 | |
|
|
1411 | 1432 | for i, ds in enumerate(self.ds): |
|
|
1433 | print(i,ds) | |
|
|
1412 | 1434 | attr, ch = self.data[i] |
|
|
1413 | 1435 | if ch == -1: |
|
|
1414 | 1436 | ds[self.blockIndex] = getattr(self.dataOut, attr) |
|
|
1415 | 1437 | else: |
|
|
1438 | print(ch, getattr(self.dataOut, attr).shape) | |
|
|
1416 | 1439 | ds[self.blockIndex] = getattr(self.dataOut, attr)[ch] |
|
|
1417 | 1440 | |
|
|
1418 | 1441 | self.fp.flush() |
| @@ -97,22 +97,27 class ParametersProc(ProcessingUnit): | |||
|
|
97 | 97 | # self.dataOut.noise = self.dataIn.noise |
|
|
98 | 98 | |
|
|
99 | 99 | def run(self): |
|
|
100 | ||
|
|
101 | ||
|
|
102 | ||
|
|
103 | 100 | #---------------------- Voltage Data --------------------------- |
|
|
104 | ||
|
|
105 | 101 | if self.dataIn.type == "Voltage": |
|
|
106 | ||
|
|
102 | print(" *************INSIDE PARAMETER********") | |
|
|
107 | 103 | self.__updateObjFromInput() |
|
|
108 | 104 | self.dataOut.data_pre = self.dataIn.data.copy() |
|
|
109 | 105 | self.dataOut.flagNoData = False |
|
|
110 | 106 | self.dataOut.utctimeInit = self.dataIn.utctime |
|
|
111 | 107 | self.dataOut.paramInterval = self.dataIn.nProfiles*self.dataIn.nCohInt*self.dataIn.ippSeconds |
|
|
112 | return | |
|
|
113 | 108 | |
|
|
109 | if self.dataIn.identifierWR== True: | |
|
|
110 | print("**********************************************") | |
|
|
111 | self.dataOut.data_intensity = self.dataIn.data #valor para intensidad | |
|
|
112 | self.dataOut.data_velocity = self.dataIn.data_velocity #valor para velocidad | |
|
|
113 | self.dataOut.identifierWR = self.dataIn.identifierWR | |
|
|
114 | self.dataOut.PRFbyAngle = self.dataIn.PRFbyAngle | |
|
|
115 | print(self.dataOut.data_intensity.shape) | |
|
|
116 | print(self.dataOut.utctimeInit) | |
|
|
117 | print(self.dataOut.nCohInt ) | |
|
|
118 | print(self.dataOut.PRFbyAngle) | |
|
|
119 | return | |
|
|
114 | 120 | #---------------------- Spectra Data --------------------------- |
|
|
115 | ||
|
|
116 | 121 | if self.dataIn.type == "Spectra": |
|
|
117 | 122 | |
|
|
118 | 123 | self.dataOut.data_pre = (self.dataIn.data_spc, self.dataIn.data_cspc) |
| @@ -130,6 +135,19 class ParametersProc(ProcessingUnit): | |||
|
|
130 | 135 | self.dataOut.groupList = self.dataIn.pairsList |
|
|
131 | 136 | self.dataOut.flagNoData = False |
|
|
132 | 137 | |
|
|
138 | if self.dataIn.flagWR== True: | |
|
|
139 | print("##############################################") | |
|
|
140 | self.dataOut.nIncohInt = self.dataIn.nIncohInt | |
|
|
141 | self.dataOut.utctimeInit = self.dataIn.utctime | |
|
|
142 | self.dataOut.data_intensity = self.dataIn.data #valor para intensidad | |
|
|
143 | self.dataOut.data_velocity = self.dataIn.data_velocity #valor para velocidad | |
|
|
144 | self.dataOut.flagWR = self.dataIn.flagWR | |
|
|
145 | self.dataOut.PRFbyAngle = self.dataIn.PRFbyAngle | |
|
|
146 | print(self.dataOut.data_intensity.shape) | |
|
|
147 | print(self.dataOut.utctimeInit) | |
|
|
148 | print(self.dataOut.nIncohInt ) | |
|
|
149 | print(self.dataOut.PRFbyAngle) | |
|
|
150 | ||
|
|
133 | 151 | if hasattr(self.dataIn, 'ChanDist'): #Distances of receiver channels |
|
|
134 | 152 | self.dataOut.ChanDist = self.dataIn.ChanDist |
|
|
135 | 153 | else: self.dataOut.ChanDist = None |
| @@ -3980,4 +3998,3 class SMOperations(): | |||
|
|
3980 | 3998 | # error[indInvalid1] = 13 |
|
|
3981 | 3999 | # |
|
|
3982 | 4000 | # return heights, error |
|
|
3983 | No newline at end of file | |
| @@ -94,6 +94,12 class SpectraProc(ProcessingUnit): | |||
|
|
94 | 94 | blocksize += dc.size |
|
|
95 | 95 | blocksize += spc.size |
|
|
96 | 96 | |
|
|
97 | #print("spc :",spc.shape) | |
|
|
98 | data_wr = None | |
|
|
99 | if self.dataOut.flagWR: | |
|
|
100 | data_wr = fft_volt | |
|
|
101 | blocksize = fft_volt.size | |
|
|
102 | ||
|
|
97 | 103 | cspc = None |
|
|
98 | 104 | pairIndex = 0 |
|
|
99 | 105 | if self.dataOut.pairsList != None: |
| @@ -115,14 +121,18 class SpectraProc(ProcessingUnit): | |||
|
|
115 | 121 | |
|
|
116 | 122 | self.dataOut.data_spc = spc |
|
|
117 | 123 | self.dataOut.data_cspc = cspc |
|
|
124 | self.dataOut.data_wr = data_wr | |
|
|
118 | 125 | self.dataOut.data_dc = dc |
|
|
119 | 126 | self.dataOut.blockSize = blocksize |
|
|
120 | 127 | self.dataOut.flagShiftFFT = False |
|
|
121 | 128 | |
|
|
122 | def run(self, nProfiles=None, nFFTPoints=None, pairsList=[], ippFactor=None, shift_fft=False): | |
|
|
129 | def run(self, nProfiles=None, nFFTPoints=None, pairsList=[], ippFactor=None, shift_fft=False,flagWR= 0): | |
|
|
130 | ||
|
|
131 | self.dataOut.flagWR = flagWR | |
|
|
123 | 132 | |
|
|
124 | 133 | if self.dataIn.type == "Spectra": |
|
|
125 | 134 | self.dataOut.copy(self.dataIn) |
|
|
135 | ||
|
|
126 | 136 | if shift_fft: |
|
|
127 | 137 | #desplaza a la derecha en el eje 2 determinadas posiciones |
|
|
128 | 138 | shift = int(self.dataOut.nFFTPoints/2) |
| @@ -135,7 +145,7 class SpectraProc(ProcessingUnit): | |||
|
|
135 | 145 | return True |
|
|
136 | 146 | |
|
|
137 | 147 | if self.dataIn.type == "Voltage": |
|
|
138 | ||
|
|
148 | #print("VOLTAGE INPUT SPECTRA") | |
|
|
139 | 149 | self.dataOut.flagNoData = True |
|
|
140 | 150 | |
|
|
141 | 151 | if nFFTPoints == None: |
| @@ -157,6 +167,7 class SpectraProc(ProcessingUnit): | |||
|
|
157 | 167 | nProfiles, |
|
|
158 | 168 | self.dataIn.nHeights), |
|
|
159 | 169 | dtype='complex') |
|
|
170 | #print("buffer :",self.buffer.shape) | |
|
|
160 | 171 | |
|
|
161 | 172 | if self.dataIn.flagDataAsBlock: |
|
|
162 | 173 | nVoltProfiles = self.dataIn.data.shape[1] |
| @@ -182,6 +193,7 class SpectraProc(ProcessingUnit): | |||
|
|
182 | 193 | self.dataOut.flagNoData = True |
|
|
183 | 194 | return 0 |
|
|
184 | 195 | else: |
|
|
196 | #print("Spectra ",self.profIndex) | |
|
|
185 | 197 | self.buffer[:, self.profIndex, :] = self.dataIn.data.copy() |
|
|
186 | 198 | self.profIndex += 1 |
|
|
187 | 199 | |
| @@ -191,6 +203,7 class SpectraProc(ProcessingUnit): | |||
|
|
191 | 203 | if self.profIndex == nProfiles: |
|
|
192 | 204 | self.__updateSpecFromVoltage() |
|
|
193 | 205 | self.__getFft() |
|
|
206 | #print(" DATAOUT SHAPE SPEC",self.dataOut.data_spc.shape) | |
|
|
194 | 207 | |
|
|
195 | 208 | self.dataOut.flagNoData = False |
|
|
196 | 209 | self.firstdatatime = None |
| @@ -941,6 +954,9 class IncohInt(Operation): | |||
|
|
941 | 954 | Add a profile to the __buffer_spc and increase in one the __profileIndex |
|
|
942 | 955 | |
|
|
943 | 956 | """ |
|
|
957 | print("profIndex: ",self.__profIndex) | |
|
|
958 | print("data_spc.shape: ",data_spc.shape) | |
|
|
959 | print("data_spc.shape: ",data_spc[0,0,:]) | |
|
|
944 | 960 | |
|
|
945 | 961 | self.__buffer_spc += data_spc |
|
|
946 | 962 | |
| @@ -1054,3 +1070,191 class IncohInt(Operation): | |||
|
|
1054 | 1070 | dataOut.flagNoData = False |
|
|
1055 | 1071 | |
|
|
1056 | 1072 | return dataOut |
|
|
1073 | ||
|
|
1074 | ||
|
|
1075 | class PulsePair(Operation): | |
|
|
1076 | isConfig = False | |
|
|
1077 | __profIndex = 0 | |
|
|
1078 | __profIndex2 = 0 | |
|
|
1079 | __initime = None | |
|
|
1080 | __lastdatatime = None | |
|
|
1081 | __buffer = None | |
|
|
1082 | __buffer2 = [] | |
|
|
1083 | __buffer3 = None | |
|
|
1084 | __dataReady = False | |
|
|
1085 | n = None | |
|
|
1086 | ||
|
|
1087 | __nch =0 | |
|
|
1088 | __nProf =0 | |
|
|
1089 | __nHeis =0 | |
|
|
1090 | ||
|
|
1091 | def __init__(self,**kwargs): | |
|
|
1092 | Operation.__init__(self,**kwargs) | |
|
|
1093 | ||
|
|
1094 | def setup(self,dataOut,n =None, m = None): | |
|
|
1095 | ||
|
|
1096 | self.__initime = None | |
|
|
1097 | self.__lastdatatime = 0 | |
|
|
1098 | self.__buffer = 0 | |
|
|
1099 | self.__bufferV = 0 | |
|
|
1100 | #self.__buffer2 = [] | |
|
|
1101 | self.__buffer3 = 0 | |
|
|
1102 | self.__dataReady = False | |
|
|
1103 | self.__profIndex = 0 | |
|
|
1104 | self.__profIndex2 = 0 | |
|
|
1105 | self.count = 0 | |
|
|
1106 | ||
|
|
1107 | ||
|
|
1108 | self.__nch = dataOut.nChannels | |
|
|
1109 | self.__nHeis = dataOut.nHeights | |
|
|
1110 | self.__nProf = dataOut.nProfiles | |
|
|
1111 | self.__nFFT = dataOut.nFFTPoints | |
|
|
1112 | #print("Valores de Ch,Samples,Perfiles,nFFT",self.__nch,self.__nHeis,self.__nProf, self.__nFFT) | |
|
|
1113 | #print("EL VALOR DE n es:",n) | |
|
|
1114 | if n == None: | |
|
|
1115 | raise ValueError("n Should be specified.") | |
|
|
1116 | ||
|
|
1117 | if n != None: | |
|
|
1118 | if n<2: | |
|
|
1119 | raise ValueError("n Should be greather than 2 ") | |
|
|
1120 | self.n = n | |
|
|
1121 | if m == None: | |
|
|
1122 | m = n | |
|
|
1123 | if m != None: | |
|
|
1124 | if m<2: | |
|
|
1125 | raise ValueError("n Should be greather than 2 ") | |
|
|
1126 | ||
|
|
1127 | self.m = m | |
|
|
1128 | self.__buffer2 = numpy.zeros((self.__nch,self.m,self.__nHeis)) | |
|
|
1129 | self.__bufferV2 = numpy.zeros((self.__nch,self.m,self.__nHeis)) | |
|
|
1130 | ||
|
|
1131 | ||
|
|
1132 | ||
|
|
1133 | def putData(self,data): | |
|
|
1134 | #print("###################################################") | |
|
|
1135 | ''' | |
|
|
1136 | data_tmp = numpy.zeros(self.__nch,self.n,self.__nHeis, dtype= complex) | |
|
|
1137 | if self.count < self.__nProf: | |
|
|
1138 | ||
|
|
1139 | for i in range(self.n): | |
|
|
1140 | data_tmp[:,i,:] = data[:,i+self.count,:] | |
|
|
1141 | ||
|
|
1142 | self.__buffer = data_tmp*numpy.conjugate(data_tmp) | |
|
|
1143 | ||
|
|
1144 | ||
|
|
1145 | #####self.__buffer = data*numpy.conjugate(data) | |
|
|
1146 | #####self.__bufferV = data[:,(self.__nProf-1):,:]*numpy.conjugate(data[:,1:,:]) | |
|
|
1147 | ||
|
|
1148 | #self.__buffer2.append(numpy.conjugate(data)) | |
|
|
1149 | ||
|
|
1150 | #####self.__profIndex = data.shape[1] | |
|
|
1151 | self.count = self.count + self.n -1 | |
|
|
1152 | self.__profIndex = self.n | |
|
|
1153 | ''' | |
|
|
1154 | self.__buffer = data*numpy.conjugate(data) | |
|
|
1155 | self.__bufferV = data[:,(self.__nProf-1):,:]*numpy.conjugate(data[:,1:,:]) | |
|
|
1156 | self.__profIndex = self.n | |
|
|
1157 | return | |
|
|
1158 | ||
|
|
1159 | def pushData(self): | |
|
|
1160 | ||
|
|
1161 | data_I = numpy.zeros((self.__nch,self.__nHeis)) | |
|
|
1162 | data_IV = numpy.zeros((self.__nch,self.__nHeis)) | |
|
|
1163 | ||
|
|
1164 | for i in range(self.__nch): | |
|
|
1165 | data_I[i,:] = numpy.sum(numpy.sum(self.__buffer[i],axis=0),axis=0)/self.n | |
|
|
1166 | data_IV[i,:] = numpy.sum(numpy.sum(self.__bufferV[i],axis=0),axis=0)/(self.n-1) | |
|
|
1167 | ||
|
|
1168 | n = self.__profIndex | |
|
|
1169 | ####data_intensity = numpy.sum(numpy.sum(self.__buffer,axis=0),axis=0)/self.n | |
|
|
1170 | #print("data_intensity push data",data_intensity.shape) | |
|
|
1171 | #data_velocity = self.__buffer3/(self.n-1) | |
|
|
1172 | ####n = self.__profIndex | |
|
|
1173 | ||
|
|
1174 | self.__buffer = 0 | |
|
|
1175 | self.__buffer3 = 0 | |
|
|
1176 | self.__profIndex = 0 | |
|
|
1177 | ||
|
|
1178 | #return data_intensity,data_velocity,n | |
|
|
1179 | return data_I,data_IV,n | |
|
|
1180 | ||
|
|
1181 | def pulsePairbyProfiles(self,data): | |
|
|
1182 | self.__dataReady = False | |
|
|
1183 | data_intensity = None | |
|
|
1184 | data_velocity = None | |
|
|
1185 | ||
|
|
1186 | self.putData(data) | |
|
|
1187 | ||
|
|
1188 | if self.__profIndex == self.n: | |
|
|
1189 | #data_intensity,data_velocity,n = self.pushData() | |
|
|
1190 | data_intensity,data_velocity,n = self.pushData() | |
|
|
1191 | #print(data_intensity.shape) | |
|
|
1192 | #print("self.__profIndex2", self.__profIndex2) | |
|
|
1193 | if self.__profIndex2 == 0: | |
|
|
1194 | #print("PRIMERA VEZ") | |
|
|
1195 | #print("self.__buffer2",self.__buffer2) | |
|
|
1196 | for i in range(self.__nch): | |
|
|
1197 | self.__buffer2[i][self.__profIndex2] = data_intensity[i] | |
|
|
1198 | self.__bufferV2[i][self.__profIndex2] = data_velocity[i] | |
|
|
1199 | self.__profIndex2 += 1 | |
|
|
1200 | return None,None | |
|
|
1201 | ||
|
|
1202 | if self.__profIndex2 > 0: | |
|
|
1203 | for i in range(self.__nch): | |
|
|
1204 | self.__buffer2[i][self.__profIndex2] = data_intensity[i] | |
|
|
1205 | self.__bufferV2[i][self.__profIndex2] = data_velocity[i] | |
|
|
1206 | #print("Dentro del bucle",self.__buffer2) | |
|
|
1207 | self.__profIndex2 += 1 | |
|
|
1208 | if self.__profIndex2 == self.m : | |
|
|
1209 | data_i = self.__buffer2 | |
|
|
1210 | data_v = self.__bufferV2 | |
|
|
1211 | #print(data_i.shape) | |
|
|
1212 | self.__dataReady = True | |
|
|
1213 | self.__profIndex2 = 0 | |
|
|
1214 | self.__buffer2 = numpy.zeros((self.__nch,self.m,self.__nHeis)) | |
|
|
1215 | self.__bufferV2 = numpy.zeros((self.__nch,self.m,self.__nHeis)) | |
|
|
1216 | return data_i,data_v | |
|
|
1217 | return None,None | |
|
|
1218 | ||
|
|
1219 | def pulsePairOp(self,data,datatime=None): | |
|
|
1220 | if self.__initime == None: | |
|
|
1221 | self.__initime = datatime | |
|
|
1222 | ||
|
|
1223 | data_intensity,data_velocity = self.pulsePairbyProfiles(data) | |
|
|
1224 | self.__lastdatatime = datatime | |
|
|
1225 | ||
|
|
1226 | if data_intensity is None: | |
|
|
1227 | return None,None,None | |
|
|
1228 | ||
|
|
1229 | avgdatatime = self.__initime | |
|
|
1230 | self.__initime = datatime | |
|
|
1231 | ||
|
|
1232 | return data_intensity,data_velocity,avgdatatime | |
|
|
1233 | ||
|
|
1234 | def run(self,dataOut,n =None,m=None): | |
|
|
1235 | ||
|
|
1236 | if not self.isConfig: | |
|
|
1237 | self.setup(dataOut = dataOut, n = n, m = m) | |
|
|
1238 | self.isConfig = True | |
|
|
1239 | ||
|
|
1240 | data_intensity,data_velocity,avgdatatime = self.pulsePairOp(dataOut.data_wr,dataOut.utctime) | |
|
|
1241 | dataOut.flagNoData = True | |
|
|
1242 | ||
|
|
1243 | if self.__dataReady: | |
|
|
1244 | #print(" DATA " , data_intensity.shape) | |
|
|
1245 | #dataOut.data = numpy.array([data_intensity])#aqui amigo revisa | |
|
|
1246 | #tmp = numpy.zeros([1,data_intensity.shape[0],data_intensity.shape[1]]) | |
|
|
1247 | #tmp[0] = data_intensity | |
|
|
1248 | dataOut.data = data_intensity | |
|
|
1249 | dataOut.data_velocity = data_velocity | |
|
|
1250 | #dataOut.data = tmp | |
|
|
1251 | #print(" DATA " , dataOut.data.shape) | |
|
|
1252 | dataOut.nIncohInt *= self.n | |
|
|
1253 | dataOut.nProfiles = self.m | |
|
|
1254 | dataOut.nFFTPoints = self.m | |
|
|
1255 | #dataOut.data_intensity = data_intensity | |
|
|
1256 | dataOut.PRFbyAngle = self.n | |
|
|
1257 | dataOut.utctime = avgdatatime | |
|
|
1258 | dataOut.flagNoData = False | |
|
|
1259 | #####print("TIEMPO: ",dataOut.utctime) | |
|
|
1260 | return dataOut | |
| @@ -384,14 +384,16 class CohInt(Operation): | |||
|
|
384 | 384 | """ |
|
|
385 | 385 | |
|
|
386 | 386 | if not self.__withOverlapping: |
|
|
387 | print("inside over") | |
|
|
387 | 388 | self.__buffer += data.copy() |
|
|
388 | 389 | self.__profIndex += 1 |
|
|
389 | 390 | return |
|
|
390 | 391 | |
|
|
391 | 392 | #Overlapping data |
|
|
392 | 393 | nChannels, nHeis = data.shape |
|
|
394 | print("show me the light",data.shape) | |
|
|
393 | 395 | data = numpy.reshape(data, (1, nChannels, nHeis)) |
|
|
394 | ||
|
|
396 | print(data.shape) | |
|
|
395 | 397 | #If the buffer is empty then it takes the data value |
|
|
396 | 398 | if self.__buffer is None: |
|
|
397 | 399 | self.__buffer = data |
| @@ -422,6 +424,7 class CohInt(Operation): | |||
|
|
422 | 424 | """ |
|
|
423 | 425 | |
|
|
424 | 426 | if not self.__withOverlapping: |
|
|
427 | #print("ahora que fue") | |
|
|
425 | 428 | data = self.__buffer |
|
|
426 | 429 | n = self.__profIndex |
|
|
427 | 430 | |
| @@ -430,6 +433,7 class CohInt(Operation): | |||
|
|
430 | 433 | |
|
|
431 | 434 | return data, n |
|
|
432 | 435 | |
|
|
436 | #print("cual funciona") | |
|
|
433 | 437 | #Integration with Overlapping |
|
|
434 | 438 | data = numpy.sum(self.__buffer, axis=0) |
|
|
435 | 439 | # print data |
| @@ -445,6 +449,7 class CohInt(Operation): | |||
|
|
445 | 449 | # n = None |
|
|
446 | 450 | # print data |
|
|
447 | 451 | # raise |
|
|
452 | #print("beforeputdata") | |
|
|
448 | 453 | self.putData(data) |
|
|
449 | 454 | |
|
|
450 | 455 | if self.__profIndex == self.n: |
| @@ -1191,6 +1196,296 class CombineProfiles(Operation): | |||
|
|
1191 | 1196 | dataOut.ippSeconds *= n |
|
|
1192 | 1197 | |
|
|
1193 | 1198 | return dataOut |
|
|
1199 | ||
|
|
1200 | ||
|
|
1201 | ||
|
|
1202 | class CreateBlockVoltage(Operation): | |
|
|
1203 | ||
|
|
1204 | isConfig = False | |
|
|
1205 | __Index = 0 | |
|
|
1206 | bufferShape = None | |
|
|
1207 | buffer = None | |
|
|
1208 | firstdatatime = None | |
|
|
1209 | ||
|
|
1210 | def __init__(self,**kwargs): | |
|
|
1211 | Operation.__init__(self,**kwargs) | |
|
|
1212 | self.isConfig = False | |
|
|
1213 | self.__Index = 0 | |
|
|
1214 | self.firstdatatime = None | |
|
|
1215 | ||
|
|
1216 | def setup(self,dataOut, m = None ): | |
|
|
1217 | ''' | |
|
|
1218 | m= Numero perfiles | |
|
|
1219 | ''' | |
|
|
1220 | #print("CONFIGURANDO CBV") | |
|
|
1221 | self.__nChannels = dataOut.nChannels | |
|
|
1222 | self.__nHeis = dataOut.nHeights | |
|
|
1223 | shape = dataOut.data.shape #nchannels, nprofiles, nsamples | |
|
|
1224 | #print("input nChannels",self.__nChannels) | |
|
|
1225 | #print("input nHeis",self.__nHeis) | |
|
|
1226 | #print("SETUP CREATE BLOCK VOLTAGE") | |
|
|
1227 | #print("input Shape",shape) | |
|
|
1228 | #print("dataOut.nProfiles",dataOut.nProfiles) | |
|
|
1229 | numberSamples = self.__nHeis | |
|
|
1230 | numberProfile = int(m) | |
|
|
1231 | dataOut.nProfiles = numberProfile | |
|
|
1232 | #print("new numberProfile",numberProfile) | |
|
|
1233 | #print("new numberSamples",numberSamples) | |
|
|
1234 | ||
|
|
1235 | self.bufferShape = shape[0], numberProfile, numberSamples # nchannels,nprofiles,nsamples | |
|
|
1236 | self.buffer = numpy.zeros((self.bufferShape)) | |
|
|
1237 | self.bufferVel = numpy.zeros((self.bufferShape)) | |
|
|
1238 | ||
|
|
1239 | def run(self, dataOut, m=None): | |
|
|
1240 | #print("RUN") | |
|
|
1241 | dataOut.flagNoData = True | |
|
|
1242 | dataOut.flagDataAsBlock = False | |
|
|
1243 | #print("BLOCK INDEX ",self.__Index) | |
|
|
1244 | ||
|
|
1245 | if not self.isConfig: | |
|
|
1246 | self.setup(dataOut, m= m) | |
|
|
1247 | self.isConfig = True | |
|
|
1248 | if self.__Index < m: | |
|
|
1249 | #print("PROFINDEX BLOCK CBV",self.__Index) | |
|
|
1250 | self.buffer[:,self.__Index,:] = dataOut.data | |
|
|
1251 | self.bufferVel[:,self.__Index,:] = dataOut.data_velocity | |
|
|
1252 | self.__Index += 1 | |
|
|
1253 | dataOut.flagNoData = True | |
|
|
1254 | ||
|
|
1255 | if self.firstdatatime == None: | |
|
|
1256 | self.firstdatatime = dataOut.utctime | |
|
|
1257 | ||
|
|
1258 | if self.__Index == m: | |
|
|
1259 | #print("**********************************************") | |
|
|
1260 | #print("self.buffer.shape ",self.buffer.shape) | |
|
|
1261 | #print("##############",self.firstdatatime) | |
|
|
1262 | ##print("*********************************************") | |
|
|
1263 | ##print("*********************************************") | |
|
|
1264 | ##print("******* nProfiles *******", dataOut.nProfiles) | |
|
|
1265 | ##print("*********************************************") | |
|
|
1266 | ##print("*********************************************") | |
|
|
1267 | dataOut.data = self.buffer | |
|
|
1268 | dataOut.data_velocity = self.bufferVel | |
|
|
1269 | dataOut.utctime = self.firstdatatime | |
|
|
1270 | dataOut.nProfiles = m | |
|
|
1271 | self.firstdatatime = None | |
|
|
1272 | dataOut.flagNoData = False | |
|
|
1273 | dataOut.flagDataAsBlock = True | |
|
|
1274 | self.__Index = 0 | |
|
|
1275 | dataOut.identifierWR = True | |
|
|
1276 | return dataOut | |
|
|
1277 | ||
|
|
1278 | class PulsePairVoltage(Operation): | |
|
|
1279 | ''' | |
|
|
1280 | Function PulsePair(Signal Power, Velocity) | |
|
|
1281 | The real component of Lag[0] provides Intensity Information | |
|
|
1282 | The imag component of Lag[1] Phase provides Velocity Information | |
|
|
1283 | ||
|
|
1284 | Configuration Parameters: | |
|
|
1285 | nPRF = Number of Several PRF | |
|
|
1286 | theta = Degree Azimuth angel Boundaries | |
|
|
1287 | ||
|
|
1288 | Input: | |
|
|
1289 | self.dataOut | |
|
|
1290 | lag[N] | |
|
|
1291 | Affected: | |
|
|
1292 | self.dataOut.spc | |
|
|
1293 | ''' | |
|
|
1294 | isConfig = False | |
|
|
1295 | __profIndex = 0 | |
|
|
1296 | __initime = None | |
|
|
1297 | __lastdatatime = None | |
|
|
1298 | __buffer = None | |
|
|
1299 | __buffer2 = [] | |
|
|
1300 | __buffer3 = None | |
|
|
1301 | __dataReady = False | |
|
|
1302 | n = None | |
|
|
1303 | __nch = 0 | |
|
|
1304 | __nHeis = 0 | |
|
|
1305 | ||
|
|
1306 | def __init__(self,**kwargs): | |
|
|
1307 | Operation.__init__(self,**kwargs) | |
|
|
1308 | ||
|
|
1309 | def setup(self, dataOut, n = None ): | |
|
|
1310 | ''' | |
|
|
1311 | n= Numero de PRF's de entrada | |
|
|
1312 | ''' | |
|
|
1313 | self.__initime = None | |
|
|
1314 | self.__lastdatatime = 0 | |
|
|
1315 | self.__dataReady = False | |
|
|
1316 | self.__buffer = 0 | |
|
|
1317 | self.__buffer2 = [] | |
|
|
1318 | self.__buffer3 = 0 | |
|
|
1319 | self.__profIndex = 0 | |
|
|
1320 | ||
|
|
1321 | self.__nch = dataOut.nChannels | |
|
|
1322 | self.__nHeis = dataOut.nHeights | |
|
|
1323 | ||
|
|
1324 | print("ELVALOR DE n es:", n) | |
|
|
1325 | if n == None: | |
|
|
1326 | raise ValueError("n should be specified.") | |
|
|
1327 | ||
|
|
1328 | if n != None: | |
|
|
1329 | if n<2: | |
|
|
1330 | raise ValueError("n should be greater than 2") | |
|
|
1331 | ||
|
|
1332 | self.n = n | |
|
|
1333 | self.__nProf = n | |
|
|
1334 | ''' | |
|
|
1335 | if overlapping: | |
|
|
1336 | self.__withOverlapping = True | |
|
|
1337 | self.__buffer = None | |
|
|
1338 | ||
|
|
1339 | else: | |
|
|
1340 | #print ("estoy sin __withO") | |
|
|
1341 | self.__withOverlapping = False | |
|
|
1342 | self.__buffer = 0 | |
|
|
1343 | self.__buffer2 = [] | |
|
|
1344 | self.__buffer3 = 0 | |
|
|
1345 | ''' | |
|
|
1346 | ||
|
|
1347 | def putData(self,data): | |
|
|
1348 | ''' | |
|
|
1349 | Add a profile to he __buffer and increase in one the __profiel Index | |
|
|
1350 | ''' | |
|
|
1351 | #print("self.__profIndex :",self.__profIndex) | |
|
|
1352 | self.__buffer += data*numpy.conjugate(data) | |
|
|
1353 | self.__buffer2.append(numpy.conjugate(data)) | |
|
|
1354 | if self.__profIndex > 0: | |
|
|
1355 | self.__buffer3 += self.__buffer2[self.__profIndex-1]*data | |
|
|
1356 | self.__profIndex += 1 | |
|
|
1357 | return | |
|
|
1358 | ''' | |
|
|
1359 | if not self.__withOverlapping: | |
|
|
1360 | #print("Putdata inside over") | |
|
|
1361 | self.__buffer += data* numpy.conjugate(data) | |
|
|
1362 | self.__buffer2.append(numpy.conjugate(data)) | |
|
|
1363 | ||
|
|
1364 | if self.__profIndex >0: | |
|
|
1365 | self.__buffer3 += self.__buffer2[self.__profIndex-1]*data | |
|
|
1366 | self.__profIndex += 1 | |
|
|
1367 | return | |
|
|
1368 | ||
|
|
1369 | if self.__buffer is None: | |
|
|
1370 | #print("aqui bro") | |
|
|
1371 | self.__buffer = data* numpy.conjugate(data) | |
|
|
1372 | self.__buffer2.append(numpy.conjugate(data)) | |
|
|
1373 | self.__profIndex += 1 | |
|
|
1374 | ||
|
|
1375 | return | |
|
|
1376 | ||
|
|
1377 | if self.__profIndex < self.n: | |
|
|
1378 | self.__buffer = numpy.vstack(self.__buffer,data* numpy.conjugate(data)) | |
|
|
1379 | self.__buffer2.append(numpy.conjugate(data)) | |
|
|
1380 | ||
|
|
1381 | if self.__profIndex == 1: | |
|
|
1382 | self.__buffer3 = self.__buffer2[self.__profIndex -1] * data | |
|
|
1383 | else: | |
|
|
1384 | self.__buffer3 = numpy.vstack(self.__buffer3, self.__buffer2[self.profIndex-1]*data) | |
|
|
1385 | ||
|
|
1386 | self.__profIndex += 1 | |
|
|
1387 | return | |
|
|
1388 | ''' | |
|
|
1389 | ||
|
|
1390 | def pushData(self): | |
|
|
1391 | ''' | |
|
|
1392 | Return the PULSEPAIR and the profiles used in the operation | |
|
|
1393 | Affected : self.__profileIndex | |
|
|
1394 | ''' | |
|
|
1395 | #print("************************************************") | |
|
|
1396 | #print("push data int vel n") | |
|
|
1397 | data_intensity = self.__buffer/self.n | |
|
|
1398 | data_velocity = self.__buffer3/(self.n-1) | |
|
|
1399 | n = self.__profIndex | |
|
|
1400 | ||
|
|
1401 | self.__buffer = 0 | |
|
|
1402 | self.__buffer2 = [] | |
|
|
1403 | self.__buffer3 = 0 | |
|
|
1404 | self.__profIndex = 0 | |
|
|
1405 | ||
|
|
1406 | return data_intensity, data_velocity,n | |
|
|
1407 | ''' | |
|
|
1408 | if not self.__withOverlapping: | |
|
|
1409 | #print("ahora que fue") | |
|
|
1410 | data_intensity = self.__buffer/self.n | |
|
|
1411 | data_velocity = self.__buffer3/(self.n-1) | |
|
|
1412 | n = self.__profIndex | |
|
|
1413 | ||
|
|
1414 | self.__buffer = 0 | |
|
|
1415 | self.__buffer2 = [] | |
|
|
1416 | self.__buffer3 = 0 | |
|
|
1417 | self.__profIndex = 0 | |
|
|
1418 | return data_intensity, data_velocity,n | |
|
|
1419 | ||
|
|
1420 | data_intensity = numpy.sum(self.__buffer,axis = 0) | |
|
|
1421 | data_velocity = numpy.sum(self.__buffer3,axis = 0) | |
|
|
1422 | n = self.__profIndex | |
|
|
1423 | #self.__buffer = 0 | |
|
|
1424 | #self.__buffer2 = [] | |
|
|
1425 | #self.__buffer3 = 0 | |
|
|
1426 | #self.__profIndex = 0 | |
|
|
1427 | return data_intensity, data_velocity,n | |
|
|
1428 | ''' | |
|
|
1429 | ||
|
|
1430 | def pulsePairbyProfiles(self,data): | |
|
|
1431 | ||
|
|
1432 | self.__dataReady = False | |
|
|
1433 | data_intensity = None | |
|
|
1434 | data_velocity = None | |
|
|
1435 | #print("beforeputada") | |
|
|
1436 | self.putData(data) | |
|
|
1437 | #print("ProfileIndex:",self.__profIndex) | |
|
|
1438 | if self.__profIndex == self.n: | |
|
|
1439 | data_intensity, data_velocity, n = self.pushData() | |
|
|
1440 | self.__dataReady = True | |
|
|
1441 | #print("-----------------------------------------------") | |
|
|
1442 | #print("data_intensity",data_intensity.shape,"data_velocity",data_velocity.shape) | |
|
|
1443 | return data_intensity, data_velocity | |
|
|
1444 | ||
|
|
1445 | def pulsePairOp(self, data, datatime= None): | |
|
|
1446 | ||
|
|
1447 | if self.__initime == None: | |
|
|
1448 | self.__initime = datatime | |
|
|
1449 | ||
|
|
1450 | data_intensity, data_velocity = self.pulsePairbyProfiles(data) | |
|
|
1451 | self.__lastdatatime = datatime | |
|
|
1452 | ||
|
|
1453 | if data_intensity is None: | |
|
|
1454 | return None, None, None | |
|
|
1455 | ||
|
|
1456 | avgdatatime = self.__initime | |
|
|
1457 | deltatime = datatime - self.__lastdatatime | |
|
|
1458 | self.__initime = datatime | |
|
|
1459 | ''' | |
|
|
1460 | if not self.__withOverlapping: | |
|
|
1461 | self.__initime = datatime | |
|
|
1462 | else: | |
|
|
1463 | self.__initime += deltatime | |
|
|
1464 | ''' | |
|
|
1465 | return data_intensity, data_velocity, avgdatatime | |
|
|
1466 | ||
|
|
1467 | def run(self, dataOut,n = None, overlapping= False,**kwargs): | |
|
|
1468 | ||
|
|
1469 | if not self.isConfig: | |
|
|
1470 | self.setup(dataOut = dataOut, n = n , **kwargs) | |
|
|
1471 | self.isConfig = True | |
|
|
1472 | #print("*******************") | |
|
|
1473 | #print("print Shape input data:",dataOut.data.shape) | |
|
|
1474 | data_intensity, data_velocity, avgdatatime = self.pulsePairOp(dataOut.data, dataOut.utctime) | |
|
|
1475 | dataOut.flagNoData = True | |
|
|
1476 | ||
|
|
1477 | if self.__dataReady: | |
|
|
1478 | #print("#------------------------------------------------------") | |
|
|
1479 | #print("data_ready",data_intensity.shape) | |
|
|
1480 | dataOut.data = data_intensity #valor para plotear RTI | |
|
|
1481 | dataOut.nCohInt *= self.n | |
|
|
1482 | dataOut.data_intensity = data_intensity #valor para intensidad | |
|
|
1483 | dataOut.data_velocity = data_velocity #valor para velocidad | |
|
|
1484 | dataOut.PRFbyAngle = self.n #numero de PRF*cada angulo rotado que equivale a un tiempo. | |
|
|
1485 | dataOut.utctime = avgdatatime | |
|
|
1486 | dataOut.flagNoData = False | |
|
|
1487 | return dataOut | |
|
|
1488 | ||
|
|
1194 | 1489 | # import collections |
|
|
1195 | 1490 | # from scipy.stats import mode |
|
|
1196 | 1491 | # |
| @@ -25,9 +25,10 controllerObj.setup(id = '191', name='Test_USRP', description=desc) | |||
|
|
25 | 25 | #path = '/media/data/data/vientos/57.2063km/echoes/NCO_Woodman' |
|
|
26 | 26 | |
|
|
27 | 27 | |
|
|
28 | path = '/home/soporte/data_hdf5' #### with clock 35.16 db noise | |
|
|
29 | ||
|
|
30 | figpath = '/home/soporte/data_hdf5_imag' | |
|
|
28 | #path = '/home/soporte/data_hdf5' #### with clock 35.16 db noise | |
|
|
29 | path = '/home/alex/WEATHER_DATA/DATA' | |
|
|
30 | figpath = '/home/alex/WEATHER_DATA/DATA/pic' | |
|
|
31 | #figpath = '/home/soporte/data_hdf5_imag' | |
|
|
31 | 32 | #remotefolder = "/home/wmaster/graficos" |
|
|
32 | 33 | ####################################################################### |
|
|
33 | 34 | ################# RANGO DE PLOTEO###################################### |
| @@ -95,14 +96,33 procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=rea | |||
|
|
95 | 96 | #opObj11.addParameter(name='nBaud', value='28', format='int') |
|
|
96 | 97 | |
|
|
97 | 98 | #opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other') |
|
|
98 |
#opObj11.addParameter(name='n', value='10 |
|
|
|
99 | #opObj11.addParameter(name='n', value='10', format='int') | |
|
|
100 | ||
|
|
101 | ||
|
|
102 | opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other') | |
|
|
103 | opObj11.addParameter(name='n', value='10', format='int') | |
|
|
104 | ||
|
|
105 | opObj11 = procUnitConfObjA.addOperation(name='CreateBlockVoltage', optype='other') | |
|
|
106 | opObj11.addParameter(name='m', value='16', format='int') | |
|
|
107 | ||
|
|
108 | procUnitConfObj2 = controllerObj.addProcUnit(datatype='ParametersProc', inputId=procUnitConfObjA.getId()) | |
|
|
99 | 109 | |
|
|
110 | #Not used because the RGB data is obtained directly from the HF Reader. | |
|
|
111 | #opObj21 = procUnitConfObj2.addOperation(name='GetRGBData') | |
|
|
112 | ||
|
|
113 | opObj21 = procUnitConfObj2.addOperation(name='ParamWriter', optype='external') | |
|
|
114 | opObj21.addParameter(name='path', value=figpath+'/NEWData') | |
|
|
115 | opObj21.addParameter(name='blocksPerFile', value='1', format='int') | |
|
|
116 | opObj21.addParameter(name='metadataList',value='heightList',format='list') | |
|
|
117 | opObj21.addParameter(name='dataList',value='data_intensity',format='list') | |
|
|
118 | ||
|
|
119 | ''' | |
|
|
100 | 120 |
|
|
|
101 | 121 |
|
|
|
102 | 122 |
|
|
|
103 | 123 | procUnitConfObjSousySpectra = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId()) |
|
|
104 |
procUnitConfObjSousySpectra.addParameter(name='nFFTPoints', value='1 |
|
|
|
105 |
procUnitConfObjSousySpectra.addParameter(name='nProfiles', value='1 |
|
|
|
124 | procUnitConfObjSousySpectra.addParameter(name='nFFTPoints', value='16', format='int') | |
|
|
125 | procUnitConfObjSousySpectra.addParameter(name='nProfiles', value='16', format='int') | |
|
|
106 | 126 |
|
|
|
107 | 127 |
|
|
|
108 | 128 |
|
| @@ -174,10 +194,10 opObj11.addParameter(name='save_period', value=10, format='int') | |||
|
|
174 | 194 |
|
|
|
175 | 195 |
|
|
|
176 | 196 |
|
|
|
197 | ''' | |
|
|
177 | 198 | print ("Escribiendo el archivo XML") |
|
|
178 | 199 | print ("Leyendo el archivo XML") |
|
|
179 | 200 | |
|
|
180 | 201 | |
|
|
181 | 202 | |
|
|
182 | 203 | controllerObj.start() |
|
|
183 | ||
General Comments 0
You need to be logged in to leave comments.
Login now