##// END OF EJS Templates
schain
RSS
PulsePairByblock
rflores -
r1438:7e8668e1fc32
parent child
Show More
Side by Side Unified
Context file:
r1438:7e8668e1fc32 Loading diff...:
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (789 lines changed) Show them Hide them
@@ -691,9 +691,9 class WeatherRHIPlot(Plot):
691 691 #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
692 692 data['azi'] = dataOut.data_azi
693 693 data['ele'] = dataOut.data_ele
694 print("UPDATE")
695 print("data[weather]",data['weather'].shape)
696 print("data[azi]",data['azi'])
694 #print("UPDATE")
695 #print("data[weather]",data['weather'].shape)
696 #print("data[azi]",data['azi'])
697 697 return data, meta
698 698
699 699 def get2List(self,angulos):
@@ -797,6 +797,13 class WeatherRHIPlot(Plot):
797 797 end = data_ele[-1]
798 798 number = (end-start)
799 799 len_ang=len(data_ele)
800 print("start",start)
801 print("end",end)
802 print("number",number)
803
804 print("len_ang",len_ang)
805
806 #exit(1)
800 807
801 808 if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
802 809 return 0
@@ -829,6 +836,7 class WeatherRHIPlot(Plot):
829 836 #----------------------------------------------------------
830 837 tipo_case = self.check_case(data_ele,ang_max,ang_min)
831 838 print("check_case",tipo_case)
839 #exit(1)
832 840 #--------------------- new -------------------------
833 841 data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
834 842
@@ -842,15 +850,21 class WeatherRHIPlot(Plot):
842 850 if tipo_case==0 or tipo_case==3: # SUBIDA
843 851 n1= round(self.start_data_ele)- start
844 852 n2= end - round(self.end_data_ele)
853 print(self.start_data_ele)
854 print(self.end_data_ele)
845 855 if n1>0:
846 856 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
847 857 ele1_nan= numpy.ones(n1)*numpy.nan
848 858 data_ele = numpy.hstack((ele1,data_ele_new))
859 print("ele1_nan",ele1_nan.shape)
860 print("data_ele_old",data_ele_old.shape)
849 861 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
850 862 if n2>0:
851 863 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
852 864 ele2_nan= numpy.ones(n2)*numpy.nan
853 865 data_ele = numpy.hstack((data_ele,ele2))
866 print("ele2_nan",ele2_nan.shape)
867 print("data_ele_old",data_ele_old.shape)
854 868 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
855 869
856 870 if tipo_case==1 or tipo_case==2: # BAJADA
@@ -1065,12 +1079,781 class WeatherRHIPlot(Plot):
1065 1079 for i,ax in enumerate(self.axes):
1066 1080 self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
1067 1081 self.res_azi = numpy.mean(data['azi'])
1082 if i==0:
1083 print("*****************************************************************************to plot**************************",self.res_weather[i].shape)
1068 1084 if ax.firsttime:
1069 1085 #plt.clf()
1070 1086 cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
1071 1087 #fig=self.figures[0]
1072 1088 else:
1073 1089 #plt.clf()
1090 if i==0:
1091 print(self.res_weather[i])
1092 print(self.res_ele)
1093 cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
1094 caax = cgax.parasites[0]
1095 paax = cgax.parasites[1]
1096 cbar = plt.gcf().colorbar(pm, pad=0.075)
1097 caax.set_xlabel('x_range [km]')
1098 caax.set_ylabel('y_range [km]')
1099 plt.text(1.0, 1.05, 'Elevacion '+str(thisDatetime)+" Step "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right')
1100 print("***************************self.ini****************************",self.ini)
1101 self.ini= self.ini+1
1102
1103 class WeatherRHI_vRF2_Plot(Plot):
1104 CODE = 'weather'
1105 plot_name = 'weather'
1106 plot_type = 'rhistyle'
1107 buffering = False
1108 data_ele_tmp = None
1109
1110 def setup(self):
1111 print("********************")
1112 print("********************")
1113 print("********************")
1114 print("SETUP WEATHER PLOT")
1115 self.ncols = 1
1116 self.nrows = 1
1117 self.nplots= 1
1118 self.ylabel= 'Range [Km]'
1119 self.titles= ['Weather']
1120 if self.channels is not None:
1121 self.nplots = len(self.channels)
1122 self.nrows = len(self.channels)
1123 else:
1124 self.nplots = self.data.shape(self.CODE)[0]
1125 self.nrows = self.nplots
1126 self.channels = list(range(self.nplots))
1127 print("channels",self.channels)
1128 print("que saldra", self.data.shape(self.CODE)[0])
1129 self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
1130 print("self.titles",self.titles)
1131 self.colorbar=False
1132 self.width =8
1133 self.height =8
1134 self.ini =0
1135 self.len_azi =0
1136 self.buffer_ini = None
1137 self.buffer_ele = None
1138 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
1139 self.flag =0
1140 self.indicador= 0
1141 self.last_data_ele = None
1142 self.val_mean = None
1143
1144 def update(self, dataOut):
1145
1146 data = {}
1147 meta = {}
1148 if hasattr(dataOut, 'dataPP_POWER'):
1149 factor = 1
1150 if hasattr(dataOut, 'nFFTPoints'):
1151 factor = dataOut.normFactor
1152 print("dataOut",dataOut.data_360.shape)
1153 #
1154 data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
1155 #
1156 #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
1157 data['azi'] = dataOut.data_azi
1158 data['ele'] = dataOut.data_ele
1159 data['case_flag'] = dataOut.case_flag
1160 #print("UPDATE")
1161 #print("data[weather]",data['weather'].shape)
1162 #print("data[azi]",data['azi'])
1163 return data, meta
1164
1165 def get2List(self,angulos):
1166 list1=[]
1167 list2=[]
1168 for i in reversed(range(len(angulos))):
1169 if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
1170 diff_ = angulos[i]-angulos[i-1]
1171 if abs(diff_) >1.5:
1172 list1.append(i-1)
1173 list2.append(diff_)
1174 return list(reversed(list1)),list(reversed(list2))
1175
1176 def fixData90(self,list_,ang_):
1177 if list_[0]==-1:
1178 vec = numpy.where(ang_<ang_[0])
1179 ang_[vec] = ang_[vec]+90
1180 return ang_
1181 return ang_
1182
1183 def fixData90HL(self,angulos):
1184 vec = numpy.where(angulos>=90)
1185 angulos[vec]=angulos[vec]-90
1186 return angulos
1187
1188
1189 def search_pos(self,pos,list_):
1190 for i in range(len(list_)):
1191 if pos == list_[i]:
1192 return True,i
1193 i=None
1194 return False,i
1195
1196 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
1197 size = len(ang_)
1198 size2 = 0
1199 for i in range(len(list2_)):
1200 size2=size2+round(abs(list2_[i]))-1
1201 new_size= size+size2
1202 ang_new = numpy.zeros(new_size)
1203 ang_new2 = numpy.zeros(new_size)
1204
1205 tmp = 0
1206 c = 0
1207 for i in range(len(ang_)):
1208 ang_new[tmp +c] = ang_[i]
1209 ang_new2[tmp+c] = ang_[i]
1210 condition , value = self.search_pos(i,list1_)
1211 if condition:
1212 pos = tmp + c + 1
1213 for k in range(round(abs(list2_[value]))-1):
1214 if tipo_case==0 or tipo_case==3:#subida
1215 ang_new[pos+k] = ang_new[pos+k-1]+1
1216 ang_new2[pos+k] = numpy.nan
1217 elif tipo_case==1 or tipo_case==2:#bajada
1218 ang_new[pos+k] = ang_new[pos+k-1]-1
1219 ang_new2[pos+k] = numpy.nan
1220
1221 tmp = pos +k
1222 c = 0
1223 c=c+1
1224 return ang_new,ang_new2
1225
1226 def globalCheckPED(self,angulos,tipo_case):
1227 l1,l2 = self.get2List(angulos)
1228 ##print("l1",l1)
1229 ##print("l2",l2)
1230 if len(l1)>0:
1231 #angulos2 = self.fixData90(list_=l1,ang_=angulos)
1232 #l1,l2 = self.get2List(angulos2)
1233 ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
1234 #ang1_ = self.fixData90HL(ang1_)
1235 #ang2_ = self.fixData90HL(ang2_)
1236 else:
1237 ang1_= angulos
1238 ang2_= angulos
1239 return ang1_,ang2_
1240
1241
1242 def replaceNAN(self,data_weather,data_ele,val):
1243 data= data_ele
1244 data_T= data_weather
1245 if data.shape[0]> data_T.shape[0]:
1246 data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
1247 c = 0
1248 for i in range(len(data)):
1249 if numpy.isnan(data[i]):
1250 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
1251 else:
1252 data_N[i,:]=data_T[c,:]
1253 c=c+1
1254 return data_N
1255 else:
1256 for i in range(len(data)):
1257 if numpy.isnan(data[i]):
1258 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
1259 return data_T
1260
1261 def check_case(self,data_ele,ang_max,ang_min):
1262 start = data_ele[0]
1263 end = data_ele[-1]
1264 number = (end-start)
1265 len_ang=len(data_ele)
1266 print("start",start)
1267 print("end",end)
1268 print("number",number)
1269
1270 print("len_ang",len_ang)
1271
1272 #exit(1)
1273
1274 if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
1275 return 0
1276 #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
1277 # return 1
1278 elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
1279 return 1
1280 elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
1281 return 2
1282 elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
1283 return 3
1284
1285
1286 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min,case_flag):
1287 ang_max= ang_max
1288 ang_min= ang_min
1289 data_weather=data_weather
1290 val_ch=val_ch
1291 ##print("*********************DATA WEATHER**************************************")
1292 ##print(data_weather)
1293 if self.ini==0:
1294 '''
1295 print("**********************************************")
1296 print("**********************************************")
1297 print("***************ini**************")
1298 print("**********************************************")
1299 print("**********************************************")
1300 '''
1301 #print("data_ele",data_ele)
1302 #----------------------------------------------------------
1303 tipo_case = case_flag[-1]
1304 #tipo_case = self.check_case(data_ele,ang_max,ang_min)
1305 print("check_case",tipo_case)
1306 #exit(1)
1307 #--------------------- new -------------------------
1308 data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
1309
1310 #-------------------------CAMBIOS RHI---------------------------------
1311 start= ang_min
1312 end = ang_max
1313 n= (ang_max-ang_min)/res
1314 #------ new
1315 self.start_data_ele = data_ele_new[0]
1316 self.end_data_ele = data_ele_new[-1]
1317 if tipo_case==0 or tipo_case==3: # SUBIDA
1318 n1= round(self.start_data_ele)- start
1319 n2= end - round(self.end_data_ele)
1320 print(self.start_data_ele)
1321 print(self.end_data_ele)
1322 if n1>0:
1323 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
1324 ele1_nan= numpy.ones(n1)*numpy.nan
1325 data_ele = numpy.hstack((ele1,data_ele_new))
1326 print("ele1_nan",ele1_nan.shape)
1327 print("data_ele_old",data_ele_old.shape)
1328 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
1329 if n2>0:
1330 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
1331 ele2_nan= numpy.ones(n2)*numpy.nan
1332 data_ele = numpy.hstack((data_ele,ele2))
1333 print("ele2_nan",ele2_nan.shape)
1334 print("data_ele_old",data_ele_old.shape)
1335 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1336
1337 if tipo_case==1 or tipo_case==2: # BAJADA
1338 data_ele_new = data_ele_new[::-1] # reversa
1339 data_ele_old = data_ele_old[::-1]# reversa
1340 data_weather = data_weather[::-1,:]# reversa
1341 vec= numpy.where(data_ele_new<ang_max)
1342 data_ele_new = data_ele_new[vec]
1343 data_ele_old = data_ele_old[vec]
1344 data_weather = data_weather[vec[0]]
1345 vec2= numpy.where(0<data_ele_new)
1346 data_ele_new = data_ele_new[vec2]
1347 data_ele_old = data_ele_old[vec2]
1348 data_weather = data_weather[vec2[0]]
1349 self.start_data_ele = data_ele_new[0]
1350 self.end_data_ele = data_ele_new[-1]
1351
1352 n1= round(self.start_data_ele)- start
1353 n2= end - round(self.end_data_ele)-1
1354 print(self.start_data_ele)
1355 print(self.end_data_ele)
1356 if n1>0:
1357 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
1358 ele1_nan= numpy.ones(n1)*numpy.nan
1359 data_ele = numpy.hstack((ele1,data_ele_new))
1360 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
1361 if n2>0:
1362 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
1363 ele2_nan= numpy.ones(n2)*numpy.nan
1364 data_ele = numpy.hstack((data_ele,ele2))
1365 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1366 # RADAR
1367 # NOTA data_ele y data_weather es la variable que retorna
1368 val_mean = numpy.mean(data_weather[:,-1])
1369 self.val_mean = val_mean
1370 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1371 print("eleold",data_ele_old)
1372 print(self.data_ele_tmp[val_ch])
1373 print(data_ele_old.shape[0])
1374 print(self.data_ele_tmp[val_ch].shape[0])
1375 if (data_ele_old.shape[0]==91 or self.data_ele_tmp[val_ch].shape[0]==91):
1376 import sys
1377 print("EXIT",self.ini)
1378
1379 sys.exit(1)
1380 self.data_ele_tmp[val_ch]= data_ele_old
1381 else:
1382 #print("**********************************************")
1383 #print("****************VARIABLE**********************")
1384 #-------------------------CAMBIOS RHI---------------------------------
1385 #---------------------------------------------------------------------
1386 ##print("INPUT data_ele",data_ele)
1387 flag=0
1388 start_ele = self.res_ele[0]
1389 #tipo_case = self.check_case(data_ele,ang_max,ang_min)
1390 tipo_case = case_flag[-1]
1391 #print("TIPO DE DATA",tipo_case)
1392 #-----------new------------
1393 data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
1394 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1395
1396 #-------------------------------NEW RHI ITERATIVO-------------------------
1397
1398 if tipo_case==0 : # SUBIDA
1399 vec = numpy.where(data_ele<ang_max)
1400 data_ele = data_ele[vec]
1401 data_ele_old = data_ele_old[vec]
1402 data_weather = data_weather[vec[0]]
1403
1404 vec2 = numpy.where(0<data_ele)
1405 data_ele= data_ele[vec2]
1406 data_ele_old= data_ele_old[vec2]
1407 ##print(data_ele_new)
1408 data_weather= data_weather[vec2[0]]
1409
1410 new_i_ele = int(round(data_ele[0]))
1411 new_f_ele = int(round(data_ele[-1]))
1412 #print(new_i_ele)
1413 #print(new_f_ele)
1414 #print(data_ele,len(data_ele))
1415 #print(data_ele_old,len(data_ele_old))
1416 if new_i_ele< 2:
1417 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
1418 self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
1419 self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
1420 self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
1421 self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
1422 data_ele = self.res_ele
1423 data_weather = self.res_weather[val_ch]
1424
1425 elif tipo_case==1 : #BAJADA
1426 data_ele = data_ele[::-1] # reversa
1427 data_ele_old = data_ele_old[::-1]# reversa
1428 data_weather = data_weather[::-1,:]# reversa
1429 vec= numpy.where(data_ele<ang_max)
1430 data_ele = data_ele[vec]
1431 data_ele_old = data_ele_old[vec]
1432 data_weather = data_weather[vec[0]]
1433 vec2= numpy.where(0<data_ele)
1434 data_ele = data_ele[vec2]
1435 data_ele_old = data_ele_old[vec2]
1436 data_weather = data_weather[vec2[0]]
1437
1438
1439 new_i_ele = int(round(data_ele[0]))
1440 new_f_ele = int(round(data_ele[-1]))
1441 #print(data_ele)
1442 #print(ang_max)
1443 #print(data_ele_old)
1444 if new_i_ele <= 1:
1445 new_i_ele = 1
1446 if round(data_ele[-1])>=ang_max-1:
1447 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
1448 self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
1449 self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
1450 self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
1451 self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
1452 data_ele = self.res_ele
1453 data_weather = self.res_weather[val_ch]
1454
1455 elif tipo_case==2: #bajada
1456 vec = numpy.where(data_ele<ang_max)
1457 data_ele = data_ele[vec]
1458 data_weather= data_weather[vec[0]]
1459
1460 len_vec = len(vec)
1461 data_ele_new = data_ele[::-1] # reversa
1462 data_weather = data_weather[::-1,:]
1463 new_i_ele = int(data_ele_new[0])
1464 new_f_ele = int(data_ele_new[-1])
1465
1466 n1= new_i_ele- ang_min
1467 n2= ang_max - new_f_ele-1
1468 if n1>0:
1469 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
1470 ele1_nan= numpy.ones(n1)*numpy.nan
1471 data_ele = numpy.hstack((ele1,data_ele_new))
1472 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
1473 if n2>0:
1474 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1475 ele2_nan= numpy.ones(n2)*numpy.nan
1476 data_ele = numpy.hstack((data_ele,ele2))
1477 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1478
1479 self.data_ele_tmp[val_ch] = data_ele_old
1480 self.res_ele = data_ele
1481 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1482 data_ele = self.res_ele
1483 data_weather = self.res_weather[val_ch]
1484
1485 elif tipo_case==3:#subida
1486 vec = numpy.where(0<data_ele)
1487 data_ele= data_ele[vec]
1488 data_ele_new = data_ele
1489 data_ele_old= data_ele_old[vec]
1490 data_weather= data_weather[vec[0]]
1491 pos_ini = numpy.argmin(data_ele)
1492 if pos_ini>0:
1493 len_vec= len(data_ele)
1494 vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
1495 #print(vec3)
1496 data_ele= data_ele[vec3]
1497 data_ele_new = data_ele
1498 data_ele_old= data_ele_old[vec3]
1499 data_weather= data_weather[vec3]
1500
1501 new_i_ele = int(data_ele_new[0])
1502 new_f_ele = int(data_ele_new[-1])
1503 n1= new_i_ele- ang_min
1504 n2= ang_max - new_f_ele-1
1505 if n1>0:
1506 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
1507 ele1_nan= numpy.ones(n1)*numpy.nan
1508 data_ele = numpy.hstack((ele1,data_ele_new))
1509 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
1510 if n2>0:
1511 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1512 ele2_nan= numpy.ones(n2)*numpy.nan
1513 data_ele = numpy.hstack((data_ele,ele2))
1514 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1515
1516 self.data_ele_tmp[val_ch] = data_ele_old
1517 self.res_ele = data_ele
1518 self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1519 data_ele = self.res_ele
1520 data_weather = self.res_weather[val_ch]
1521 #print("self.data_ele_tmp",self.data_ele_tmp)
1522 return data_weather,data_ele
1523
1524
1525 def plot(self):
1526 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
1527 data = self.data[-1]
1528 r = self.data.yrange
1529 delta_height = r[1]-r[0]
1530 r_mask = numpy.where(r>=0)[0]
1531 ##print("delta_height",delta_height)
1532 #print("r_mask",r_mask,len(r_mask))
1533 r = numpy.arange(len(r_mask))*delta_height
1534 self.y = 2*r
1535 res = 1
1536 ###print("data['weather'].shape[0]",data['weather'].shape[0])
1537 ang_max = self.ang_max
1538 ang_min = self.ang_min
1539 var_ang =ang_max - ang_min
1540 step = (int(var_ang)/(res*data['weather'].shape[0]))
1541 ###print("step",step)
1542 #--------------------------------------------------------
1543 ##print('weather',data['weather'].shape)
1544 ##print('ele',data['ele'].shape)
1545
1546 ###self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
1547 ###self.res_azi = numpy.mean(data['azi'])
1548 ###print("self.res_ele",self.res_ele)
1549 plt.clf()
1550 subplots = [121, 122]
1551 try:
1552 if self.data[-2]['ele'].max()<data['ele'].max():
1553 self.ini=0
1554 except:
1555 pass
1556 if self.ini==0:
1557 self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
1558 self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
1559 print("SHAPE",self.data_ele_tmp.shape)
1560
1561 for i,ax in enumerate(self.axes):
1562 self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min,case_flag=self.data['case_flag'])
1563 self.res_azi = numpy.mean(data['azi'])
1564
1565 if ax.firsttime:
1566 #plt.clf()
1567 print("Frist Plot")
1568 cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
1569 #fig=self.figures[0]
1570 else:
1571 #plt.clf()
1572 print("ELSE PLOT")
1573 cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
1574 caax = cgax.parasites[0]
1575 paax = cgax.parasites[1]
1576 cbar = plt.gcf().colorbar(pm, pad=0.075)
1577 caax.set_xlabel('x_range [km]')
1578 caax.set_ylabel('y_range [km]')
1579 plt.text(1.0, 1.05, 'Elevacion '+str(thisDatetime)+" Step "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right')
1580 print("***************************self.ini****************************",self.ini)
1581 self.ini= self.ini+1
1582
1583 class WeatherRHI_vRF_Plot(Plot):
1584 CODE = 'weather'
1585 plot_name = 'weather'
1586 plot_type = 'rhistyle'
1587 buffering = False
1588 data_ele_tmp = None
1589
1590 def setup(self):
1591 print("********************")
1592 print("********************")
1593 print("********************")
1594 print("SETUP WEATHER PLOT")
1595 self.ncols = 1
1596 self.nrows = 1
1597 self.nplots= 1
1598 self.ylabel= 'Range [Km]'
1599 self.titles= ['Weather']
1600 if self.channels is not None:
1601 self.nplots = len(self.channels)
1602 self.nrows = len(self.channels)
1603 else:
1604 self.nplots = self.data.shape(self.CODE)[0]
1605 self.nrows = self.nplots
1606 self.channels = list(range(self.nplots))
1607 print("channels",self.channels)
1608 print("que saldra", self.data.shape(self.CODE)[0])
1609 self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
1610 print("self.titles",self.titles)
1611 self.colorbar=False
1612 self.width =8
1613 self.height =8
1614 self.ini =0
1615 self.len_azi =0
1616 self.buffer_ini = None
1617 self.buffer_ele = None
1618 self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
1619 self.flag =0
1620 self.indicador= 0
1621 self.last_data_ele = None
1622 self.val_mean = None
1623
1624 def update(self, dataOut):
1625
1626 data = {}
1627 meta = {}
1628 if hasattr(dataOut, 'dataPP_POWER'):
1629 factor = 1
1630 if hasattr(dataOut, 'nFFTPoints'):
1631 factor = dataOut.normFactor
1632 print("dataOut",dataOut.data_360.shape)
1633 #
1634 data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
1635 #
1636 #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
1637 data['azi'] = dataOut.data_azi
1638 data['ele'] = dataOut.data_ele
1639 data['case_flag'] = dataOut.case_flag
1640 #print("UPDATE")
1641 #print("data[weather]",data['weather'].shape)
1642 #print("data[azi]",data['azi'])
1643 return data, meta
1644
1645 def get2List(self,angulos):
1646 list1=[]
1647 list2=[]
1648 #print(angulos)
1649 #exit(1)
1650 for i in reversed(range(len(angulos))):
1651 if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
1652 diff_ = angulos[i]-angulos[i-1]
1653 if abs(diff_) >1.5:
1654 list1.append(i-1)
1655 list2.append(diff_)
1656 return list(reversed(list1)),list(reversed(list2))
1657
1658 def fixData90(self,list_,ang_):
1659 if list_[0]==-1:
1660 vec = numpy.where(ang_<ang_[0])
1661 ang_[vec] = ang_[vec]+90
1662 return ang_
1663 return ang_
1664
1665 def fixData90HL(self,angulos):
1666 vec = numpy.where(angulos>=90)
1667 angulos[vec]=angulos[vec]-90
1668 return angulos
1669
1670
1671 def search_pos(self,pos,list_):
1672 for i in range(len(list_)):
1673 if pos == list_[i]:
1674 return True,i
1675 i=None
1676 return False,i
1677
1678 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
1679 size = len(ang_)
1680 size2 = 0
1681 for i in range(len(list2_)):
1682 size2=size2+round(abs(list2_[i]))-1
1683 new_size= size+size2
1684 ang_new = numpy.zeros(new_size)
1685 ang_new2 = numpy.zeros(new_size)
1686
1687 tmp = 0
1688 c = 0
1689 for i in range(len(ang_)):
1690 ang_new[tmp +c] = ang_[i]
1691 ang_new2[tmp+c] = ang_[i]
1692 condition , value = self.search_pos(i,list1_)
1693 if condition:
1694 pos = tmp + c + 1
1695 for k in range(round(abs(list2_[value]))-1):
1696 if tipo_case==0 or tipo_case==3:#subida
1697 ang_new[pos+k] = ang_new[pos+k-1]+1
1698 ang_new2[pos+k] = numpy.nan
1699 elif tipo_case==1 or tipo_case==2:#bajada
1700 ang_new[pos+k] = ang_new[pos+k-1]-1
1701 ang_new2[pos+k] = numpy.nan
1702
1703 tmp = pos +k
1704 c = 0
1705 c=c+1
1706 return ang_new,ang_new2
1707
1708 def globalCheckPED(self,angulos,tipo_case):
1709 l1,l2 = self.get2List(angulos)
1710 print("l1",l1)
1711 print("l2",l2)
1712 if len(l1)>0:
1713 #angulos2 = self.fixData90(list_=l1,ang_=angulos)
1714 #l1,l2 = self.get2List(angulos2)
1715 ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
1716 #ang1_ = self.fixData90HL(ang1_)
1717 #ang2_ = self.fixData90HL(ang2_)
1718 else:
1719 ang1_= angulos
1720 ang2_= angulos
1721 return ang1_,ang2_
1722
1723
1724 def replaceNAN(self,data_weather,data_ele,val):
1725 data= data_ele
1726 data_T= data_weather
1727 #print(data.shape[0])
1728 #print(data_T.shape[0])
1729 #exit(1)
1730 if data.shape[0]> data_T.shape[0]:
1731 data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
1732 c = 0
1733 for i in range(len(data)):
1734 if numpy.isnan(data[i]):
1735 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
1736 else:
1737 data_N[i,:]=data_T[c,:]
1738 c=c+1
1739 return data_N
1740 else:
1741 for i in range(len(data)):
1742 if numpy.isnan(data[i]):
1743 data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
1744 return data_T
1745
1746
1747 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min,case_flag):
1748 ang_max= ang_max
1749 ang_min= ang_min
1750 data_weather=data_weather
1751 val_ch=val_ch
1752 ##print("*********************DATA WEATHER**************************************")
1753 ##print(data_weather)
1754
1755 '''
1756 print("**********************************************")
1757 print("**********************************************")
1758 print("***************ini**************")
1759 print("**********************************************")
1760 print("**********************************************")
1761 '''
1762 #print("data_ele",data_ele)
1763 #----------------------------------------------------------
1764
1765 #exit(1)
1766 tipo_case = case_flag[-1]
1767 print("tipo_case",tipo_case)
1768 #--------------------- new -------------------------
1769 data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
1770
1771 #-------------------------CAMBIOS RHI---------------------------------
1772
1773 vec = numpy.where(data_ele<ang_max)
1774 data_ele = data_ele[vec]
1775 data_weather= data_weather[vec[0]]
1776
1777 len_vec = len(vec)
1778 data_ele_new = data_ele[::-1] # reversa
1779 data_weather = data_weather[::-1,:]
1780 new_i_ele = int(data_ele_new[0])
1781 new_f_ele = int(data_ele_new[-1])
1782
1783 n1= new_i_ele- ang_min
1784 n2= ang_max - new_f_ele-1
1785 if n1>0:
1786 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
1787 ele1_nan= numpy.ones(n1)*numpy.nan
1788 data_ele = numpy.hstack((ele1,data_ele_new))
1789 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
1790 if n2>0:
1791 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
1792 ele2_nan= numpy.ones(n2)*numpy.nan
1793 data_ele = numpy.hstack((data_ele,ele2))
1794 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
1795
1796
1797 print("ele shape",data_ele.shape)
1798 print(data_ele)
1799
1800 #print("self.data_ele_tmp",self.data_ele_tmp)
1801 val_mean = numpy.mean(data_weather[:,-1])
1802 self.val_mean = val_mean
1803 data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
1804 self.data_ele_tmp[val_ch]= data_ele_old
1805
1806
1807 print("data_weather shape",data_weather.shape)
1808 print(data_weather)
1809 #exit(1)
1810 return data_weather,data_ele
1811
1812
1813 def plot(self):
1814 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
1815 data = self.data[-1]
1816 r = self.data.yrange
1817 delta_height = r[1]-r[0]
1818 r_mask = numpy.where(r>=0)[0]
1819 ##print("delta_height",delta_height)
1820 #print("r_mask",r_mask,len(r_mask))
1821 r = numpy.arange(len(r_mask))*delta_height
1822 self.y = 2*r
1823 res = 1
1824 ###print("data['weather'].shape[0]",data['weather'].shape[0])
1825 ang_max = self.ang_max
1826 ang_min = self.ang_min
1827 var_ang =ang_max - ang_min
1828 step = (int(var_ang)/(res*data['weather'].shape[0]))
1829 ###print("step",step)
1830 #--------------------------------------------------------
1831 ##print('weather',data['weather'].shape)
1832 ##print('ele',data['ele'].shape)
1833
1834 ###self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
1835 ###self.res_azi = numpy.mean(data['azi'])
1836 ###print("self.res_ele",self.res_ele)
1837 plt.clf()
1838 subplots = [121, 122]
1839 if self.ini==0:
1840 self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
1841 self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
1842 print("SHAPE",self.data_ele_tmp.shape)
1843
1844 for i,ax in enumerate(self.axes):
1845 self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min,case_flag=self.data['case_flag'])
1846 self.res_azi = numpy.mean(data['azi'])
1847
1848 print(self.res_ele)
1849 #exit(1)
1850 if ax.firsttime:
1851 #plt.clf()
1852 cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
1853 #fig=self.figures[0]
1854 else:
1855
1856 #plt.clf()
1074 1857 cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
1075 1858 caax = cgax.parasites[0]
1076 1859 paax = cgax.parasites[1]
Show file before | Show file after | Hide comments
@@ -565,7 +565,7 class DigitalRFReader(ProcessingUnit):
565 565 return True
566 566
567 567 def __isBufferEmpty(self):
568
568
569 569 return self.__bufferIndex > self.__samples_to_read - self.__nSamples # 40960 - 40
570 570
571 571 def getData(self, seconds=30, nTries=5):
@@ -636,6 +636,7 class DigitalRFReader(ProcessingUnit):
636 636 self.dataOut.flagNoData = False
637 637 buffer = self.__data_buffer[:,self.__bufferIndex:self.__bufferIndex + self.__samples_to_read]
638 638 buffer = buffer.reshape((self.__nChannels, self.nProfileBlocks, int(self.__samples_to_read/self.nProfileBlocks)))
639 self.dataOut.nProfileBlocks = self.nProfileBlocks
639 640 self.dataOut.data = buffer
640 641 self.dataOut.utctime = ( self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
641 642 self.profileIndex += self.__samples_to_read
Show file before | Show file after | Hide comments
@@ -4071,6 +4071,7 class PedestalInformation(Operation):
4071 4071 # utc_ped_list.append(self.gettimeutcfromDirFilename(path=self.path_ped,file=list_pedestal[i]))
4072 4072 nro_file,utc_ped,utc_ped_1 =self.getNROFile(utc_adq,utc_ped_list)
4073 4073 #print("NROFILE************************************", nro_file,utc_ped)
4074 #print(nro_file)
4074 4075 if nro_file < 0:
4075 4076 return numpy.NaN,numpy.NaN
4076 4077 else:
@@ -4090,6 +4091,8 class PedestalInformation(Operation):
4090 4091 return numpy.NaN,numpy.NaN
4091 4092 #------------------------------------------------------------------------------------------------------
4092 4093 '''
4094 #print(int(self.samp_rate_ped))
4095 #print(nro_key_p)
4093 4096 if int(self.samp_rate_ped)-1>=nro_key_p>0:
4094 4097 #print("angulo_array :",angulo[nro_key_p])
4095 4098 return angulo[nro_key_p],angulo_ele[nro_key_p]
@@ -4195,10 +4198,13 class PedestalInformation(Operation):
4195 4198 self.samp_rate_ped= samp_rate_ped
4196 4199 self.t_Interval_p = t_Interval_p
4197 4200 self.list_pedestal = self.getfirstFilefromPath(path=self.path_ped,meta="pos@",ext=".h5")
4201
4198 4202 self.utc_ped_list= []
4199 4203 for i in range(len(self.list_pedestal)):
4200 4204 #print(i,self.gettimeutcfromDirFilename(path=self.path_ped,file=self.list_pedestal[i]))# OJO IDENTIFICADOR DE SINCRONISMO
4201 4205 self.utc_ped_list.append(self.gettimeutcfromDirFilename(path=self.path_ped,file=self.list_pedestal[i]))
4206 #print(self.utc_ped_list)
4207 #exit(1)
4202 4208 #print("que paso")
4203 4209 dataOut.wr_exp = wr_exp
4204 4210 #print("SETUP READY")
@@ -4218,6 +4224,8 class PedestalInformation(Operation):
4218 4224
4219 4225 def run(self, dataOut,path_ped,samp_rate_ped,t_Interval_p,wr_exp):
4220 4226 #print("INTEGRATION -----")
4227 #print("PEDESTAL")
4228
4221 4229 if not self.isConfig:
4222 4230 self.setup(dataOut, path_ped,samp_rate_ped,t_Interval_p,wr_exp)
4223 4231 self.__dataReady = True
@@ -4231,11 +4239,18 class PedestalInformation(Operation):
4231 4239 angulo,angulo_ele = self.getAnguloProfile(utc_adq=utc_adq,utc_ped_list=self.utc_ped_list)
4232 4240 #print("angulo**********",angulo)
4233 4241 dataOut.flagNoData = False
4242
4234 4243 if numpy.isnan(angulo) or numpy.isnan(angulo_ele) :
4244 #print("PEDESTAL 3")
4245 #exit(1)
4235 4246 dataOut.flagNoData = True
4236 4247 return dataOut
4237 4248 dataOut.azimuth = angulo
4238 4249 dataOut.elevation = angulo_ele
4250 #print("PEDESTAL END")
4251 #print(dataOut.azimuth)
4252 #print(dataOut.elevation)
4253 #exit(1)
4239 4254 return dataOut
4240 4255
4241 4256 class Block360(Operation):
@@ -4373,6 +4388,8 class Block360(Operation):
4373 4388
4374 4389 def run(self, dataOut,n = None,mode=None,**kwargs):
4375 4390 #print("BLOCK 360 HERE WE GO MOMENTOS")
4391 print("Block 360")
4392 #exit(1)
4376 4393 if not self.isConfig:
4377 4394 self.setup(dataOut = dataOut, n = n ,mode= mode ,**kwargs)
4378 4395 ####self.index = 0
@@ -4388,7 +4405,7 class Block360(Operation):
4388 4405 #print("DATA 360")
4389 4406 #print(dataOut.data_360)
4390 4407 #print("---------------------------------------------------------------------------------")
4391 #print("---------------------------DATAREADY---------------------------------------------")
4408 print("---------------------------DATAREADY---------------------------------------------")
4392 4409 #print("---------------------------------------------------------------------------------")
4393 4410 #print("data_360",dataOut.data_360.shape)
4394 4411 dataOut.data_azi = data_p
@@ -4399,3 +4416,207 class Block360(Operation):
4399 4416 dataOut.utctime = avgdatatime
4400 4417 dataOut.flagNoData = False
4401 4418 return dataOut
4419
4420 class Block360_vRF(Operation):
4421 '''
4422 '''
4423 isConfig = False
4424 __profIndex = 0
4425 __initime = None
4426 __lastdatatime = None
4427 __buffer = None
4428 __dataReady = False
4429 n = None
4430 __nch = 0
4431 __nHeis = 0
4432 index = 0
4433 mode = 0
4434
4435 def __init__(self,**kwargs):
4436 Operation.__init__(self,**kwargs)
4437
4438 def setup(self, dataOut, n = None, mode = None):
4439 '''
4440 n= Numero de PRF's de entrada
4441 '''
4442 self.__initime = None
4443 self.__lastdatatime = 0
4444 self.__dataReady = False
4445 self.__buffer = 0
4446 self.__buffer_1D = 0
4447 self.__profIndex = 0
4448 self.index = 0
4449 self.__nch = dataOut.nChannels
4450 self.__nHeis = dataOut.nHeights
4451 ##print("ELVALOR DE n es:", n)
4452 if n == None:
4453 raise ValueError("n should be specified.")
4454
4455 if mode == None:
4456 raise ValueError("mode should be specified.")
4457
4458 if n != None:
4459 if n<1:
4460 print("n should be greater than 2")
4461 raise ValueError("n should be greater than 2")
4462
4463 self.n = n
4464 self.mode = mode
4465 #print("self.mode",self.mode)
4466 #print("nHeights")
4467 self.__buffer = numpy.zeros(( dataOut.nChannels,n, dataOut.nHeights))
4468 self.__buffer2 = numpy.zeros(n)
4469 self.__buffer3 = numpy.zeros(n)
4470
4471
4472
4473
4474 def putData(self,data,mode):
4475 '''
4476 Add a profile to he __buffer and increase in one the __profiel Index
4477 '''
4478 #print("line 4049",data.dataPP_POW.shape,data.dataPP_POW[:10])
4479 #print("line 4049",data.azimuth.shape,data.azimuth)
4480 if self.mode==0:
4481 self.__buffer[:,self.__profIndex,:]= data.dataPP_POWER# PRIMER MOMENTO
4482 if self.mode==1:
4483 self.__buffer[:,self.__profIndex,:]= data.data_pow
4484 #print("me casi",self.index,data.azimuth[self.index])
4485 #print(self.__profIndex, self.index , data.azimuth[self.index] )
4486 #print("magic",data.profileIndex)
4487 #print(data.azimuth[self.index])
4488 #print("index",self.index)
4489
4490 #####self.__buffer2[self.__profIndex] = data.azimuth[self.index]
4491 self.__buffer2[self.__profIndex] = data.azimuth
4492 self.__buffer3[self.__profIndex] = data.elevation
4493 #print("q pasa")
4494 #####self.index+=1
4495 #print("index",self.index,data.azimuth[:10])
4496 self.__profIndex += 1
4497 return #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Remove DCΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
4498
4499 def pushData(self,data):
4500 '''
4501 Return the PULSEPAIR and the profiles used in the operation
4502 Affected : self.__profileIndex
4503 '''
4504 #print("pushData")
4505
4506 data_360 = self.__buffer
4507 data_p = self.__buffer2
4508 data_e = self.__buffer3
4509 n = self.__profIndex
4510
4511 self.__buffer = numpy.zeros((self.__nch, self.n,self.__nHeis))
4512 self.__buffer2 = numpy.zeros(self.n)
4513 self.__buffer3 = numpy.zeros(self.n)
4514 self.__profIndex = 0
4515 #print("pushData")
4516 return data_360,n,data_p,data_e
4517
4518
4519 def byProfiles(self,dataOut):
4520
4521 self.__dataReady = False
4522 data_360 = None
4523 data_p = None
4524 data_e = None
4525 #print("dataOu",dataOut.dataPP_POW)
4526 self.putData(data=dataOut,mode = self.mode)
4527 ##### print("profIndex",self.__profIndex)
4528 if self.__profIndex == self.n:
4529 data_360,n,data_p,data_e = self.pushData(data=dataOut)
4530 self.__dataReady = True
4531
4532 return data_360,data_p,data_e
4533
4534
4535 def blockOp(self, dataOut, datatime= None):
4536 if self.__initime == None:
4537 self.__initime = datatime
4538 data_360,data_p,data_e = self.byProfiles(dataOut)
4539 self.__lastdatatime = datatime
4540
4541 if data_360 is None:
4542 return None, None,None,None
4543
4544
4545 avgdatatime = self.__initime
4546 if self.n==1:
4547 avgdatatime = datatime
4548 deltatime = datatime - self.__lastdatatime
4549 self.__initime = datatime
4550 #print(data_360.shape,avgdatatime,data_p.shape)
4551 return data_360,avgdatatime,data_p,data_e
4552
4553 def checkcase(self,data_ele):
4554 start = data_ele[0]
4555 end = data_ele[-1]
4556 diff_angle = (end-start)
4557 len_ang=len(data_ele)
4558 print("start",start)
4559 print("end",end)
4560 print("number",diff_angle)
4561
4562 print("len_ang",len_ang)
4563
4564 aux = (data_ele<0).any(axis=0)
4565
4566 #exit(1)
4567 if diff_angle<0 and aux!=1: #Bajada
4568 return 1
4569 elif diff_angle<0 and aux==1: #Bajada con angulos negativos
4570 return 0
4571 elif diff_angle == 0: # This case happens when the angle reaches the max_angle if n = 2
4572 self.flagEraseFirstData = 1
4573 print("ToDO this case")
4574 exit(1)
4575 elif diff_angle>0: #Subida
4576 return 0
4577
4578 def run(self, dataOut,n = None,mode=None,**kwargs):
4579 #print("BLOCK 360 HERE WE GO MOMENTOS")
4580 print("Block 360")
4581
4582 #exit(1)
4583 if not self.isConfig:
4584 if n == 1:
4585 print("*******************Min Value is 2. Setting n = 2*******************")
4586 n = 2
4587 #exit(1)
4588 print(n)
4589 self.setup(dataOut = dataOut, n = n ,mode= mode ,**kwargs)
4590 ####self.index = 0
4591 #print("comova",self.isConfig)
4592 self.isConfig = True
4593 ####if self.index==dataOut.azimuth.shape[0]:
4594 #### self.index=0
4595 data_360, avgdatatime,data_p,data_e = self.blockOp(dataOut, dataOut.utctime)
4596 dataOut.flagNoData = True
4597
4598 if self.__dataReady:
4599 dataOut.data_360 = data_360 # S
4600 #print("DATA 360")
4601 #print(dataOut.data_360)
4602 #print("---------------------------------------------------------------------------------")
4603 print("---------------------------DATAREADY---------------------------------------------")
4604 #print("---------------------------------------------------------------------------------")
4605 #print("data_360",dataOut.data_360.shape)
4606 dataOut.data_azi = data_p
4607 dataOut.data_ele = data_e
4608 ###print("azi: ",dataOut.data_azi)
4609 #print("ele: ",dataOut.data_ele)
4610 #print("jroproc_parameters",data_p[0],data_p[-1])#,data_360.shape,avgdatatime)
4611 dataOut.utctime = avgdatatime
4612
4613 dataOut.case_flag = self.checkcase(dataOut.data_ele)
4614 if dataOut.case_flag: #Si estΓ‘ de bajada empieza a plotear
4615 print("INSIDE CASE FLAG BAJADA")
4616 dataOut.flagNoData = False
4617 else:
4618 print("CASE SUBIDA")
4619 dataOut.flagNoData = True
4620
4621 #dataOut.flagNoData = False
4622 return dataOut
Show file before | Show file after | Hide comments
@@ -216,7 +216,7 class selectHeights(Operation):
216 216
217 217 if (maxIndex >= self.dataOut.nHeights):
218 218 maxIndex = self.dataOut.nHeights
219
219 #print("shapeeee",self.dataOut.data.shape)
220 220 #voltage
221 221 if self.dataOut.flagDataAsBlock:
222 222 """
@@ -1472,7 +1472,10 class PulsePair(Operation):
1472 1472 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf, avgdatatime
1473 1473
1474 1474 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
1475
1475 #print("hey")
1476 #print(dataOut.data.shape)
1477 #exit(1)
1478 #print(self.__profIndex)
1476 1479 if not self.isConfig:
1477 1480 self.setup(dataOut = dataOut, n = n , removeDC=removeDC , **kwargs)
1478 1481 self.isConfig = True
@@ -1494,7 +1497,233 class PulsePair(Operation):
1494 1497 dataOut.flagNoData = False
1495 1498 return dataOut
1496 1499
1500 class PulsePair_vRF(Operation):
1501 '''
1502 Function PulsePair(Signal Power, Velocity)
1503 The real component of Lag[0] provides Intensity Information
1504 The imag component of Lag[1] Phase provides Velocity Information
1505
1506 Configuration Parameters:
1507 nPRF = Number of Several PRF
1508 theta = Degree Azimuth angel Boundaries
1509
1510 Input:
1511 self.dataOut
1512 lag[N]
1513 Affected:
1514 self.dataOut.spc
1515 '''
1516 isConfig = False
1517 __profIndex = 0
1518 __initime = None
1519 __lastdatatime = None
1520 __buffer = None
1521 noise = None
1522 __dataReady = False
1523 n = None
1524 __nch = 0
1525 __nHeis = 0
1526 removeDC = False
1527 ipp = None
1528 lambda_ = 0
1529
1530 def __init__(self,**kwargs):
1531 Operation.__init__(self,**kwargs)
1497 1532
1533 def setup(self, dataOut, n = None, removeDC=False):
1534 '''
1535 n= Numero de PRF's de entrada
1536 '''
1537 self.__initime = None
1538 ####print("[INICIO]-setup del METODO PULSE PAIR")
1539 self.__lastdatatime = 0
1540 self.__dataReady = False
1541 self.__buffer = 0
1542 self.__profIndex = 0
1543 self.noise = None
1544 self.__nch = dataOut.nChannels
1545 self.__nHeis = dataOut.nHeights
1546 self.removeDC = removeDC
1547 self.lambda_ = 3.0e8/(9345.0e6)
1548 self.ippSec = dataOut.ippSeconds
1549 self.nCohInt = dataOut.nCohInt
1550 ####print("IPPseconds",dataOut.ippSeconds)
1551 ####print("ELVALOR DE n es:", n)
1552 if n == None:
1553 raise ValueError("n should be specified.")
1554
1555 if n != None:
1556 if n<2:
1557 raise ValueError("n should be greater than 2")
1558
1559 self.n = n
1560 self.__nProf = n
1561
1562 self.__buffer = numpy.zeros((dataOut.nChannels,
1563 n,
1564 dataOut.nHeights),
1565 dtype='complex')
1566
1567 def putData(self,data):
1568 '''
1569 Add a profile to he __buffer and increase in one the __profiel Index
1570 '''
1571 self.__buffer[:,self.__profIndex,:]= data
1572 self.__profIndex += 1
1573 return
1574
1575 def putDataByBlock(self,data,n):
1576 '''
1577 Add a profile to he __buffer and increase in one the __profiel Index
1578 '''
1579 self.__buffer[:]= data
1580 self.__profIndex = n
1581 return
1582
1583 def pushData(self,dataOut):
1584 '''
1585 Return the PULSEPAIR and the profiles used in the operation
1586 Affected : self.__profileIndex
1587 '''
1588 #----------------- Remove DC-----------------------------------
1589 if self.removeDC==True:
1590 mean = numpy.mean(self.__buffer,1)
1591 tmp = mean.reshape(self.__nch,1,self.__nHeis)
1592 dc= numpy.tile(tmp,[1,self.__nProf,1])
1593 self.__buffer = self.__buffer - dc
1594 #------------------Calculo de Potencia ------------------------
1595 pair0 = self.__buffer*numpy.conj(self.__buffer)
1596 pair0 = pair0.real
1597 lag_0 = numpy.sum(pair0,1)
1598 #-----------------Calculo de Cscp------------------------------ New
1599 cspc_pair01 = self.__buffer[0]*self.__buffer[1]
1600 #------------------Calculo de Ruido x canal--------------------
1601 self.noise = numpy.zeros(self.__nch)
1602 for i in range(self.__nch):
1603 daux = numpy.sort(pair0[i,:,:],axis= None)
1604 self.noise[i]=hildebrand_sekhon( daux ,self.nCohInt)
1605
1606 self.noise = self.noise.reshape(self.__nch,1)
1607 self.noise = numpy.tile(self.noise,[1,self.__nHeis])
1608 noise_buffer = self.noise.reshape(self.__nch,1,self.__nHeis)
1609 noise_buffer = numpy.tile(noise_buffer,[1,self.__nProf,1])
1610 #------------------ Potencia recibida= P , Potencia senal = S , Ruido= N--
1611 #------------------ P= S+N ,P=lag_0/N ---------------------------------
1612 #-------------------- Power --------------------------------------------------
1613 data_power = lag_0/(self.n*self.nCohInt)
1614 #--------------------CCF------------------------------------------------------
1615 data_ccf =numpy.sum(cspc_pair01,axis=0)/(self.n*self.nCohInt)
1616 #------------------ Senal --------------------------------------------------
1617 data_intensity = pair0 - noise_buffer
1618 data_intensity = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
1619 #data_intensity = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
1620 for i in range(self.__nch):
1621 for j in range(self.__nHeis):
1622 if data_intensity[i][j] < 0:
1623 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
1624
1625 #----------------- Calculo de Frecuencia y Velocidad doppler--------
1626 pair1 = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
1627 lag_1 = numpy.sum(pair1,1)
1628 data_freq = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
1629 data_velocity = (self.lambda_/2.0)*data_freq
1630
1631 #---------------- Potencia promedio estimada de la Senal-----------
1632 lag_0 = lag_0/self.n
1633 S = lag_0-self.noise
1634
1635 #---------------- Frecuencia Doppler promedio ---------------------
1636 lag_1 = lag_1/(self.n-1)
1637 R1 = numpy.abs(lag_1)
1638
1639 #---------------- Calculo del SNR----------------------------------
1640 data_snrPP = S/self.noise
1641 for i in range(self.__nch):
1642 for j in range(self.__nHeis):
1643 if data_snrPP[i][j] < 1.e-20:
1644 data_snrPP[i][j] = 1.e-20
1645
1646 #----------------- Calculo del ancho espectral ----------------------
1647 L = S/R1
1648 L = numpy.where(L<0,1,L)
1649 L = numpy.log(L)
1650 tmp = numpy.sqrt(numpy.absolute(L))
1651 data_specwidth = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec*self.nCohInt))*tmp*numpy.sign(L)
1652 n = self.__profIndex
1653
1654 self.__buffer = numpy.zeros((self.__nch, self.__nProf,self.__nHeis), dtype='complex')
1655 self.__profIndex = 0
1656 return data_power,data_intensity,data_velocity,data_snrPP,data_specwidth,data_ccf,n
1657
1658
1659 def pulsePairbyProfiles(self,dataOut,n):
1660
1661 self.__dataReady = False
1662 data_power = None
1663 data_intensity = None
1664 data_velocity = None
1665 data_specwidth = None
1666 data_snrPP = None
1667 data_ccf = None
1668
1669 if dataOut.flagDataAsBlock:
1670 self.putDataByBlock(data=dataOut.data,n=n)
1671 else:
1672 self.putData(data=dataOut.data)
1673 if self.__profIndex == self.n:
1674 data_power,data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, n = self.pushData(dataOut=dataOut)
1675 self.__dataReady = True
1676
1677 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf
1678
1679
1680 def pulsePairOp(self, dataOut, n, datatime= None):
1681
1682 if self.__initime == None:
1683 self.__initime = datatime
1684 data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf = self.pulsePairbyProfiles(dataOut,n)
1685 self.__lastdatatime = datatime
1686
1687 if data_power is None:
1688 return None, None, None,None,None,None,None
1689
1690 avgdatatime = self.__initime
1691 deltatime = datatime - self.__lastdatatime
1692 self.__initime = datatime
1693
1694 return data_power, data_intensity, data_velocity, data_snrPP,data_specwidth,data_ccf, avgdatatime
1695
1696 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
1697 #print("hey")
1698 #print(dataOut.data.shape)
1699 #exit(1)
1700 if dataOut.flagDataAsBlock:
1701 n = dataOut.nProfileBlocks
1702 #print(self.__profIndex)
1703 if not self.isConfig:
1704 self.setup(dataOut = dataOut, n = n , removeDC=removeDC , **kwargs)
1705 self.isConfig = True
1706
1707
1708 data_power, data_intensity, data_velocity,data_snrPP,data_specwidth,data_ccf, avgdatatime = self.pulsePairOp(dataOut, n, dataOut.utctime)
1709
1710
1711 dataOut.flagNoData = True
1712
1713 if self.__dataReady:
1714 ###print("READY ----------------------------------")
1715 dataOut.nCohInt *= self.n
1716 dataOut.dataPP_POW = data_intensity # S
1717 dataOut.dataPP_POWER = data_power # P valor que corresponde a POTENCIA MOMENTO
1718 dataOut.dataPP_DOP = data_velocity
1719 dataOut.dataPP_SNR = data_snrPP
1720 dataOut.dataPP_WIDTH = data_specwidth
1721 dataOut.dataPP_CCF = data_ccf
1722 dataOut.PRFbyAngle = self.n #numero de PRF*cada angulo rotado que equivale a un tiempo.
1723 dataOut.nProfiles = int(dataOut.nProfiles/n)
1724 dataOut.utctime = avgdatatime
1725 dataOut.flagNoData = False
1726 return dataOut
1498 1727
1499 1728 # import collections
1500 1729 # from scipy.stats import mode
General Comments 0
You need to be logged in to leave comments. Login now