##// END OF EJS Templates
schain
RSS
Merge branch 'v3.0-devel' of http://jro-dev.igp.gob.pe/rhodecode/schain into v3.0-devel
Juan C. Espinoza -
r1323:133a5771abd8 merge
parent child
Show More
Side by Side Unified
Context file:
r1323:133a5771abd8 Loading diff...:
Show file before | Show file after | Hide comments
@@ -0,0 +1,87
1 import numpy
2 import sys
3 import zmq
4 import time
5 import h5py
6 import os
7
8 path="/home/alex/Downloads/pedestal"
9 ext=".hdf5"
10
11 port ="5556"
12 if len(sys.argv)>1:
13 port = sys.argv[1]
14 int(port)
15
16 if len(sys.argv)>2:
17 port1 = sys.argv[2]
18 int(port1)
19
20 #Socket to talk to server
21 context = zmq.Context()
22 socket = context.socket(zmq.SUB)
23
24 print("Collecting updates from weather server...")
25 socket.connect("tcp://localhost:%s"%port)
26
27 if len(sys.argv)>2:
28 socket.connect("tcp://localhost:%s"%port1)
29
30 #Subscribe to zipcode, default is NYC,10001
31 topicfilter = "10001"
32 socket.setsockopt_string(zmq.SUBSCRIBE,topicfilter)
33 #Process 5 updates
34 total_value=0
35 count= -1
36 azi= []
37 elev=[]
38 time0=[]
39 #for update_nbr in range(250):
40 while(True):
41 string= socket.recv()
42 topic,ang_elev,ang_elev_dec,ang_azi,ang_azi_dec,seconds,seconds_dec= string.split()
43 ang_azi =float(ang_azi)+1e-3*float(ang_azi_dec)
44 ang_elev =float(ang_elev)+1e-3*float(ang_elev_dec)
45 seconds =float(seconds) +1e-6*float(seconds_dec)
46 azi.append(ang_azi)
47 elev.append(ang_elev)
48 time0.append(seconds)
49 count +=1
50 if count == 100:
51 timetuple=time.localtime()
52 epoc = time.mktime(timetuple)
53 #print(epoc)
54 fullpath = path + ("/" if path[-1]!="/" else "")
55
56 if not os.path.exists(fullpath):
57 os.mkdir(fullpath)
58
59 azi_array = numpy.array(azi)
60 elev_array = numpy.array(elev)
61 time0_array= numpy.array(time0)
62 pedestal_array=numpy.array([azi,elev,time0])
63 count=0
64 azi= []
65 elev=[]
66 time0=[]
67 #print(pedestal_array[0])
68 #print(pedestal_array[1])
69
70 meta='PE'
71 filex="%s%4.4d%3.3d%10.4d%s"%(meta,timetuple.tm_year,timetuple.tm_yday,epoc,ext)
72 filename = os.path.join(fullpath,filex)
73 fp = h5py.File(filename,'w')
74 #print("Escribiendo HDF5...",epoc)
75 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· DataΒ·....Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
76 grp = fp.create_group("Data")
77 dset = grp.create_dataset("azimuth" , data=pedestal_array[0])
78 dset = grp.create_dataset("elevacion", data=pedestal_array[1])
79 dset = grp.create_dataset("utc" , data=pedestal_array[2])
80 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· MetadataΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
81 grp = fp.create_group("Metadata")
82 dset = grp.create_dataset("utctimeInit", data=pedestal_array[2][0])
83 timeInterval = pedestal_array[2][1]-pedestal_array[2][0]
84 dset = grp.create_dataset("timeInterval", data=timeInterval)
85 fp.close()
86
87 #print ("Average messagedata value for topic '%s' was %dF" % ( topicfilter,total_value / update_nbr))
Show file before | Show file after | Hide comments
@@ -0,0 +1,48
1 ###########################################################################
2 ############################### SERVIDOR###################################
3 ######################### SIMULADOR DE PEDESTAL############################
4 ###########################################################################
5 import time
6 import math
7 import numpy
8 import struct
9 from time import sleep
10 import zmq
11 import pickle
12 port="5556"
13 context = zmq.Context()
14 socket = context.socket(zmq.PUB)
15 socket.bind("tcp://*:%s"%port)
16 ###### PARAMETROS DE ENTRADA################################
17 print("PEDESTAL RESOLUCION 0.01")
18 print("MAXIMA VELOCIDAD DEL PEDESTAL")
19 ang_elev = 4.12
20 ang_azi = 30
21 velocidad= input ("Ingresa velocidad:")
22 velocidad= float(velocidad)
23 print (velocidad)
24 ############################################################
25 sleep(3)
26 print("Start program")
27 t1 = time.time()
28 count=0
29 while(True):
30 tmp_vuelta = int(360/velocidad)
31 t1=t1+tmp_vuelta*count
32 count= count+1
33 muestras_seg = 100
34 t2 = time.time()
35 for i in range(tmp_vuelta):
36 for j in range(muestras_seg):
37 tmp_variable = (i+j/100.0)
38 ang_azi = (tmp_variable)*float(velocidad)
39 seconds = t1+ tmp_variable
40 topic=10001
41 print ("AzimΒ°: ","%.4f"%ang_azi,"Time:" ,"%.5f"%seconds)
42 seconds_dec=(seconds-int(seconds))*1e6
43 ang_azi_dec= (ang_azi-int(ang_azi))*1e3
44 ang_elev_dec=(ang_elev-int(ang_elev))*1e3
45 sleep(0.0088)
46 socket.send_string("%d %d %d %d %d %d %d"%(topic,ang_elev,ang_elev_dec,ang_azi,ang_azi_dec,seconds,seconds_dec))
47 t3 = time.time()
48 print ("Total time for 1 vuelta in Seconds",t3-t2)
Show file before | Show file after | Hide comments
@@ -0,0 +1,82
1 import os, sys
2 import datetime
3 import time
4 from schainpy.controller import Project
5
6 desc = "USRP_test"
7 filename = "USRP_processing.xml"
8 controllerObj = Project()
9 controllerObj.setup(id = '191', name='Test_USRP', description=desc)
10
11 ############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
12 ######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
13 path = '/home/alex/Downloads/test_rawdata'
14 figpath = '/home/alex/Downloads/hdf5_test'
15 ######################## UNIDAD DE LECTURA#############################
16 '''
17 readUnitConfObj = controllerObj.addReadUnit(datatype='VoltageReader',
18 path=path,
19 startDate="2020/01/01", #"2020/01/01",#today,
20 endDate= "2020/12/01", #"2020/12/30",#today,
21 startTime='00:00:00',
22 endTime='23:59:59',
23 delay=0,
24 #set=0,
25 online=0,
26 walk=1)
27
28 '''
29 readUnitConfObj = controllerObj.addReadUnit(datatype='SimulatorReader',
30 frequency=9.345e9,
31 FixRCP_IPP= 60,
32 Tau_0 = 30,
33 AcqH0_0=0,
34 samples=330,
35 AcqDH_0=0.15,
36 FixRCP_TXA=0.15,
37 FixRCP_TXB=0.15,
38 Fdoppler=600.0,
39 Hdoppler=36,
40 Adoppler=300,#300
41 delay=0,
42 online=0,
43 walk=0,
44 profilesPerBlock=625,
45 dataBlocksPerFile=100)
46 #nTotalReadFiles=2)
47
48
49 #opObj11 = readUnitConfObj.addOperation(name='printInfo')
50
51 procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
52
53 procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
54 procUnitConfObjB.addParameter(name='nFFTPoints', value=625, format='int')
55 procUnitConfObjB.addParameter(name='nProfiles', value=625, format='int')
56
57 opObj11 = procUnitConfObjB.addOperation(name='removeDC')
58 opObj11.addParameter(name='mode', value=2)
59 #opObj11 = procUnitConfObjB.addOperation(name='SpectraPlot')
60 #opObj11 = procUnitConfObjB.addOperation(name='PowerProfilePlot')
61
62 procUnitConfObjC= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjB.getId())
63 procUnitConfObjC.addOperation(name='SpectralMoments')
64 #opObj11 = procUnitConfObjC.addOperation(name='PowerPlot')
65
66 '''
67 opObj11 = procUnitConfObjC.addOperation(name='SpectralMomentsPlot')
68 #opObj11.addParameter(name='xmin', value=14)
69 #opObj11.addParameter(name='xmax', value=15)
70 #opObj11.addParameter(name='save', value=figpath)
71 opObj11.addParameter(name='showprofile', value=1)
72 #opObj11.addParameter(name='save_period', value=10)
73 '''
74
75 opObj10 = procUnitConfObjC.addOperation(name='ParameterWriter')
76 opObj10.addParameter(name='path',value=figpath)
77 #opObj10.addParameter(name='mode',value=0)
78 opObj10.addParameter(name='blocksPerFile',value='100',format='int')
79 opObj10.addParameter(name='metadataList',value='utctimeInit,timeInterval',format='list')
80 opObj10.addParameter(name='dataList',value='data_POW,data_DOP,data_WIDTH,data_SNR')#,format='list'
81
82 controllerObj.start()
Show file before | Show file after | Hide comments
@@ -0,0 +1,162
1 import os,numpy,h5py
2 from shutil import copyfile
3
4 def isNumber(str):
5 try:
6 float(str)
7 return True
8 except:
9 return False
10
11 def getfirstFilefromPath(path,meta,ext):
12 validFilelist = []
13 fileList = os.listdir(path)
14 if len(fileList)<1:
15 return None
16 # meta 1234 567 8-18 BCDE
17 # H,D,PE YYYY DDD EPOC .ext
18
19 for thisFile in fileList:
20 if meta =="PE":
21 try:
22 number= int(thisFile[len(meta)+7:len(meta)+17])
23 except:
24 print("There is a file or folder with different format")
25 if meta == "D":
26 try:
27 number= int(thisFile[8:11])
28 except:
29 print("There is a file or folder with different format")
30
31 if not isNumber(str=number):
32 continue
33 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
34 continue
35 validFilelist.sort()
36 validFilelist.append(thisFile)
37 if len(validFilelist)>0:
38 validFilelist = sorted(validFilelist,key=str.lower)
39 return validFilelist
40 return None
41
42 def gettimeutcfromDirFilename(path,file):
43 dir_file= path+"/"+file
44 fp = h5py.File(dir_file,'r')
45 epoc = fp['Metadata'].get('utctimeInit')[()]
46 fp.close()
47 return epoc
48
49 def getDatavaluefromDirFilename(path,file,value):
50 dir_file= path+"/"+file
51 fp = h5py.File(dir_file,'r')
52 array = fp['Data'].get(value)[()]
53 fp.close()
54 return array
55
56
57 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Velocidad de PedestalΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
58 w = input ("Ingresa velocidad de Pedestal: ")
59 w = 4
60 w = float(w)
61 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Resolucion minimo en gradosΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
62 alfa = input ("Ingresa resolucion minima en grados: ")
63 alfa = 1
64 alfa = float(alfa)
65 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· IPP del Experimento Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
66 IPP = input ("Ingresa el IPP del experimento: ")
67 IPP = 0.0004
68 IPP = float(IPP)
69 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· MODE Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
70 mode = input ("Ingresa el MODO del experimento T or F: ")
71 mode = "T"
72 mode = str(mode)
73
74 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Tiempo en generar la resolucion minΒ·Β·Β·
75 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· MCU Β·Β· var_ang = w * (var_tiempo)Β·Β·Β·
76 var_tiempo = alfa/w
77 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Tiempo Equivalente en perfilesΒ·Β·Β·Β·Β·Β·Β·Β·
78 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· var_tiempo = IPP * ( num_perfiles )Β·
79 num_perfiles = int(var_tiempo/IPP)
80
81 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·DATA PEDESTALΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
82 dir_pedestal = "/home/alex/Downloads/pedestal"
83 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· DATA ADQΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
84 if mode=="T":
85 dir_adq = "/home/alex/Downloads/hdf5_testPP/d2020194" # Time domain
86 else:
87 dir_adq = "/home/alex/Downloads/hdf5_test/d2020194" # Frequency domain
88
89 print( "Velocidad angular :", w)
90 print( "Resolucion minima en grados :", alfa)
91 print( "Numero de perfiles equivalente:", num_perfiles)
92 print( "Mode :", mode)
93
94 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· First FileΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
95 list_pedestal = getfirstFilefromPath(path=dir_pedestal,meta="PE",ext=".hdf5")
96 list_adq = getfirstFilefromPath(path=dir_adq ,meta="D",ext=".hdf5")
97
98 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· utc time Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
99 utc_pedestal= gettimeutcfromDirFilename(path=dir_pedestal,file=list_pedestal[0])
100 utc_adq = gettimeutcfromDirFilename(path=dir_adq ,file=list_adq[0])
101
102 print("utc_pedestal :",utc_pedestal)
103 print("utc_adq :",utc_adq)
104 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Relacion: utc_adq (+/-) var_tiempo*nro_file= utc_pedestal
105 time_Interval_p = 0.01
106 n_perfiles_p = 100
107 if utc_adq>utc_pedestal:
108 nro_file = int((int(utc_adq) - int(utc_pedestal))/(time_Interval_p*n_perfiles_p))
109 ff_pedestal = list_pedestal[nro_file]
110 utc_pedestal = gettimeutcfromDirFilename(path=dir_pedestal,file=ff_pedestal)
111 nro_key_p = int((utc_adq-utc_pedestal)/time_Interval_p)
112 if utc_adq >utc_pedestal:
113 ff_pedestal = ff_pedestal
114 else:
115 nro_file = nro_file-1
116 ff_pedestal = list_pedestal[nro_file]
117 angulo = getDatavaluefromDirFilename(path=dir_pedestal,file=ff_pedestal,value="azimuth")
118 nro_key_p = int((utc_adq-utc_pedestal)/time_Interval_p)
119 print("nro_file :",nro_file)
120 print("name_file :",ff_pedestal)
121 print("utc_pedestal_file :",utc_pedestal)
122 print("nro_key_p :",nro_key_p)
123 print("utc_pedestal_init :",utc_pedestal+nro_key_p*time_Interval_p)
124 print("angulo_array :",angulo[nro_key_p])
125 #4+25+25+25+21
126 #while True:
127 list_pedestal = getfirstFilefromPath(path=dir_pedestal,meta="PE",ext=".hdf5")
128 list_adq = getfirstFilefromPath(path=dir_adq ,meta="D",ext=".hdf5")
129
130 nro_file = nro_file #10
131 nro_key_perfil = nro_key_p
132 blocksPerFile = 100
133 wr_path = "/home/alex/Downloads/hdf5_wr/"
134 # Lectura de archivos de adquisicion para adicion de azimuth
135 for thisFile in range(len(list_adq)):
136 print("thisFileAdq",thisFile)
137 angulo_adq = numpy.zeros(blocksPerFile)
138 tmp = 0
139 for j in range(blocksPerFile):
140 iterador = nro_key_perfil + 25*(j-tmp)
141 if iterador < n_perfiles_p:
142 nro_file = nro_file
143 else:
144 nro_file = nro_file+1
145 tmp = j
146 iterador = nro_key_perfil
147 ff_pedestal = list_pedestal[nro_file]
148 angulo = getDatavaluefromDirFilename(path=dir_pedestal,file=ff_pedestal,value="azimuth")
149 angulo_adq[j]= angulo[iterador]
150 copyfile(dir_adq+"/"+list_adq[thisFile],wr_path+list_adq[thisFile])
151 fp = h5py.File(wr_path+list_adq[thisFile],'a')
152 grp = fp.create_group("Pedestal")
153 dset = grp.create_dataset("azimuth" , data=angulo_adq)
154 fp.close()
155 print("Angulo",angulo_adq)
156 print("Angulo",len(angulo_adq))
157 nro_key_perfil=iterador + 25
158 if nro_key_perfil< n_perfiles_p:
159 nro_file = nro_file
160 else:
161 nro_file = nro_file+1
162 nro_key_perfil= nro_key_p
Show file before | Show file after | Hide comments
@@ -360,9 +360,11 class Voltage(JROData):
360 360
361 361 # data es un numpy array de 2 dmensiones (canales, alturas)
362 362 data = None
363 data_intensity = None
364 data_velocity = None
365 data_specwidth = None
363 dataPP_POW = None
364 dataPP_DOP = None
365 dataPP_WIDTH = None
366 dataPP_SNR = None
367
366 368 def __init__(self):
367 369 '''
368 370 Constructor
@@ -1208,7 +1210,7 class PlotterData(object):
1208 1210 '''
1209 1211 Update data object with new dataOut
1210 1212 '''
1211
1213
1212 1214 self.profileIndex = dataOut.profileIndex
1213 1215 self.tm = tm
1214 1216 self.type = dataOut.type
@@ -1261,15 +1263,19 class PlotterData(object):
1261 1263 self.flagDataAsBlock = dataOut.flagDataAsBlock
1262 1264 self.nProfiles = dataOut.nProfiles
1263 1265 if plot == 'pp_power':
1264 buffer = dataOut.data_intensity
1266 buffer = dataOut.dataPP_POWER
1267 self.flagDataAsBlock = dataOut.flagDataAsBlock
1268 self.nProfiles = dataOut.nProfiles
1269 if plot == 'pp_signal':
1270 buffer = dataOut.dataPP_POW
1265 1271 self.flagDataAsBlock = dataOut.flagDataAsBlock
1266 1272 self.nProfiles = dataOut.nProfiles
1267 1273 if plot == 'pp_velocity':
1268 buffer = dataOut.data_velocity
1274 buffer = dataOut.dataPP_DOP
1269 1275 self.flagDataAsBlock = dataOut.flagDataAsBlock
1270 1276 self.nProfiles = dataOut.nProfiles
1271 1277 if plot == 'pp_specwidth':
1272 buffer = dataOut.data_specwidth
1278 buffer = dataOut.dataPP_WIDTH
1273 1279 self.flagDataAsBlock = dataOut.flagDataAsBlock
1274 1280 self.nProfiles = dataOut.nProfiles
1275 1281
Show file before | Show file after | Hide comments
@@ -156,6 +156,8 class ScopePlot(Plot):
156 156 thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1])
157 157 if self.CODE == "pp_power":
158 158 scope = self.data['pp_power']
159 elif self.CODE == "pp_signal":
160 scope = self.data["pp_signal"]
159 161 elif self.CODE == "pp_velocity":
160 162 scope = self.data["pp_velocity"]
161 163 elif self.CODE == "pp_specwidth":
@@ -191,6 +193,13 class ScopePlot(Plot):
191 193 thisDatetime,
192 194 wintitle
193 195 )
196 if self.CODE=="pp_signal":
197 self.plot_weatherpower(self.data.heights,
198 scope[:,i,:],
199 channels,
200 thisDatetime,
201 wintitle
202 )
194 203 if self.CODE=="pp_velocity":
195 204 self.plot_weathervelocity(scope[:,i,:],
196 205 self.data.heights,
@@ -230,6 +239,13 class ScopePlot(Plot):
230 239 thisDatetime,
231 240 wintitle
232 241 )
242 if self.CODE=="pp_signal":
243 self.plot_weatherpower(self.data.heights,
244 scope,
245 channels,
246 thisDatetime,
247 wintitle
248 )
233 249 if self.CODE=="pp_velocity":
234 250 self.plot_weathervelocity(scope,
235 251 self.data.heights,
@@ -249,7 +265,7 class ScopePlot(Plot):
249 265
250 266 class PulsepairPowerPlot(ScopePlot):
251 267 '''
252 Plot for
268 Plot for P= S+N
253 269 '''
254 270
255 271 CODE = 'pp_power'
@@ -259,7 +275,7 class PulsepairPowerPlot(ScopePlot):
259 275
260 276 class PulsepairVelocityPlot(ScopePlot):
261 277 '''
262 Plot for
278 Plot for VELOCITY
263 279 '''
264 280 CODE = 'pp_velocity'
265 281 plot_name = 'PulsepairVelocity'
@@ -268,9 +284,19 class PulsepairVelocityPlot(ScopePlot):
268 284
269 285 class PulsepairSpecwidthPlot(ScopePlot):
270 286 '''
271 Plot for
287 Plot for WIDTH
272 288 '''
273 289 CODE = 'pp_specwidth'
274 290 plot_name = 'PulsepairSpecwidth'
275 291 plot_type = 'scatter'
276 292 buffering = False
293
294 class PulsepairSignalPlot(ScopePlot):
295 '''
296 Plot for S
297 '''
298
299 CODE = 'pp_signal'
300 plot_name = 'PulsepairSignal'
301 plot_type = 'scatter'
302 buffering = False
Show file before | Show file after | Hide comments
@@ -360,21 +360,27 class SimulatorReader(JRODataReader, ProcessingUnit):
360 360 fd = Fdoppler #+(600.0/120)*self.nReadBlocks
361 361 d_signal = Adoppler*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
362 362 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·SeΓ±al con ancho espectralΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
363 #specw_sig = numpy.linspace(-149,150,300)
364 #w = 8
365 #A = 20
366 #specw_sig = specw_sig/w
367 #specw_sig = numpy.sinc(specw_sig)
368 #specw_sig = A*numpy.array(specw_sig,dtype=numpy.complex64)
363 if prof_gen%2==0:
364 min = int(prof_gen/2.0-1.0)
365 max = int(prof_gen/2.0)
366 else:
367 min = int(prof_gen/2.0)
368 max = int(prof_gen/2.0)
369 specw_sig = numpy.linspace(-min,max,prof_gen)
370 w = 4
371 A = 20
372 specw_sig = specw_sig/w
373 specw_sig = numpy.sinc(specw_sig)
374 specw_sig = A*numpy.array(specw_sig,dtype=numpy.complex64)
369 375 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· DATABLOCK + DOPPLERΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
370 376 HD=int(Hdoppler/self.AcqDH_0)
371 377 for i in range(12):
372 378 self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ d_signal# RESULT
373 379 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· DATABLOCK + DOPPLER*Sinc(x)Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
374 #HD=int(Hdoppler/self.AcqDH_0)
375 #HD=int(HD/2)
376 #for i in range(12):
377 # self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT
380 HD=int(Hdoppler/self.AcqDH_0)
381 HD=int(HD/2)
382 for i in range(12):
383 self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT
378 384
379 385 def readBlock(self):
380 386
@@ -421,7 +427,8 class SimulatorReader(JRODataReader, ProcessingUnit):
421 427 FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,
422 428 FixRCP_TXA = 40, FixRCP_TXB = 50, fAngle = 2.0*math.pi*(1/16),DC_level= 50,
423 429 stdev= 8,Num_Codes = 1 , Dyn_snCode = None, samples=200,
424 channels=2,Fdoppler=20,Hdoppler=36,Adoppler=500,nTotalReadFiles=10000,
430 channels=2,Fdoppler=20,Hdoppler=36,Adoppler=500,
431 profilesPerBlock=300,dataBlocksPerFile=120,nTotalReadFiles=10000,
425 432 **kwargs):
426 433
427 434 self.set_kwargs(**kwargs)
@@ -447,14 +454,14 class SimulatorReader(JRODataReader, ProcessingUnit):
447 454 codeType=0, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,
448 455 flip1=0, flip2=0,Taus=Tau_0)
449 456
450 self.set_PH(dtype=0, blockSize=0, profilesPerBlock=300,
451 dataBlocksPerFile=120, nWindows=1, processFlags=numpy.array([1024]), nCohInt=1,
457 self.set_PH(dtype=0, blockSize=0, profilesPerBlock=profilesPerBlock,
458 dataBlocksPerFile=dataBlocksPerFile, nWindows=1, processFlags=numpy.array([1024]), nCohInt=1,
452 459 nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0,
453 460 deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0,
454 461 code=0, nBaud=None, shif_fft=False, flag_dc=False,
455 462 flag_cspc=False, flag_decode=False, flag_deflip=False)
456 463
457 self.set_SH(nSamples=samples, nProfiles=300, nChannels=channels)
464 self.set_SH(nSamples=samples, nProfiles=profilesPerBlock, nChannels=channels)
458 465
459 466 self.readFirstHeader()
460 467
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (2141 lines changed) Show them Hide them
@@ -8,12 +8,12 import copy
8 8 import sys
9 9 import importlib
10 10 import itertools
11 from multiprocessing import Pool, TimeoutError
11 from multiprocessing import Pool, TimeoutError
12 12 from multiprocessing.pool import ThreadPool
13 13 import time
14 14
15 15 from scipy.optimize import fmin_l_bfgs_b #optimize with bounds on state papameters
16 from .jroproc_base import ProcessingUnit, Operation, MPDecorator
16 from .jroproc_base import ProcessingUnit, Operation, MPDecorator
17 17 from schainpy.model.data.jrodata import Parameters, hildebrand_sekhon
18 18 from scipy import asarray as ar,exp
19 19 from scipy.optimize import curve_fit
@@ -48,13 +48,13 def _unpickle_method(func_name, obj, cls):
48 48
49 49
50 50 class ParametersProc(ProcessingUnit):
51
51
52 52 METHODS = {}
53 53 nSeconds = None
54 54
55 55 def __init__(self):
56 56 ProcessingUnit.__init__(self)
57
57
58 58 # self.objectDict = {}
59 59 self.buffer = None
60 60 self.firstdatatime = None
@@ -63,14 +63,14 class ParametersProc(ProcessingUnit):
63 63 self.setupReq = False #Agregar a todas las unidades de proc
64 64
65 65 def __updateObjFromInput(self):
66
66
67 67 self.dataOut.inputUnit = self.dataIn.type
68
68
69 69 self.dataOut.timeZone = self.dataIn.timeZone
70 70 self.dataOut.dstFlag = self.dataIn.dstFlag
71 71 self.dataOut.errorCount = self.dataIn.errorCount
72 72 self.dataOut.useLocalTime = self.dataIn.useLocalTime
73
73
74 74 self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
75 75 self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
76 76 self.dataOut.channelList = self.dataIn.channelList
@@ -92,27 +92,41 class ParametersProc(ProcessingUnit):
92 92 self.dataOut.ippSeconds = self.dataIn.ippSeconds
93 93 # self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
94 94 self.dataOut.timeInterval1 = self.dataIn.timeInterval
95 self.dataOut.heightList = self.dataIn.getHeiRange()
95 self.dataOut.heightList = self.dataIn.getHeiRange()
96 96 self.dataOut.frequency = self.dataIn.frequency
97 97 # self.dataOut.noise = self.dataIn.noise
98
98
99 99 def run(self):
100 100
101 101
102 102
103 103 #---------------------- Voltage Data ---------------------------
104
104
105 105 if self.dataIn.type == "Voltage":
106 106
107 107 self.__updateObjFromInput()
108 108 self.dataOut.data_pre = self.dataIn.data.copy()
109 109 self.dataOut.flagNoData = False
110 110 self.dataOut.utctimeInit = self.dataIn.utctime
111 self.dataOut.paramInterval = self.dataIn.nProfiles*self.dataIn.nCohInt*self.dataIn.ippSeconds
111 self.dataOut.paramInterval = self.dataIn.nProfiles*self.dataIn.nCohInt*self.dataIn.ippSeconds
112 if hasattr(self.dataIn, 'dataPP_POW'):
113 self.dataOut.dataPP_POW = self.dataIn.dataPP_POW
114
115 if hasattr(self.dataIn, 'dataPP_POWER'):
116 self.dataOut.dataPP_POWER = self.dataIn.dataPP_POWER
117
118 if hasattr(self.dataIn, 'dataPP_DOP'):
119 self.dataOut.dataPP_DOP = self.dataIn.dataPP_DOP
120
121 if hasattr(self.dataIn, 'dataPP_SNR'):
122 self.dataOut.dataPP_SNR = self.dataIn.dataPP_SNR
123
124 if hasattr(self.dataIn, 'dataPP_WIDTH'):
125 self.dataOut.dataPP_WIDTH = self.dataIn.dataPP_WIDTH
112 126 return
113
127
114 128 #---------------------- Spectra Data ---------------------------
115
129
116 130 if self.dataIn.type == "Spectra":
117 131
118 132 self.dataOut.data_pre = (self.dataIn.data_spc, self.dataIn.data_cspc)
@@ -126,243 +140,243 class ParametersProc(ProcessingUnit):
126 140 self.dataOut.spc_noise = self.dataIn.getNoise()
127 141 self.dataOut.spc_range = (self.dataIn.getFreqRange(1) , self.dataIn.getAcfRange(1) , self.dataIn.getVelRange(1))
128 142 # self.dataOut.normFactor = self.dataIn.normFactor
129 self.dataOut.pairsList = self.dataIn.pairsList
143 self.dataOut.pairsList = self.dataIn.pairsList
130 144 self.dataOut.groupList = self.dataIn.pairsList
131 self.dataOut.flagNoData = False
132
145 self.dataOut.flagNoData = False
146
133 147 if hasattr(self.dataIn, 'ChanDist'): #Distances of receiver channels
134 148 self.dataOut.ChanDist = self.dataIn.ChanDist
135 else: self.dataOut.ChanDist = None
136
149 else: self.dataOut.ChanDist = None
150
137 151 #if hasattr(self.dataIn, 'VelRange'): #Velocities range
138 152 # self.dataOut.VelRange = self.dataIn.VelRange
139 153 #else: self.dataOut.VelRange = None
140
154
141 155 if hasattr(self.dataIn, 'RadarConst'): #Radar Constant
142 156 self.dataOut.RadarConst = self.dataIn.RadarConst
143
157
144 158 if hasattr(self.dataIn, 'NPW'): #NPW
145 159 self.dataOut.NPW = self.dataIn.NPW
146
160
147 161 if hasattr(self.dataIn, 'COFA'): #COFA
148 162 self.dataOut.COFA = self.dataIn.COFA
149
150
151
163
164
165
152 166 #---------------------- Correlation Data ---------------------------
153
167
154 168 if self.dataIn.type == "Correlation":
155 169 acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.dataIn.splitFunctions()
156
170
157 171 self.dataOut.data_pre = (self.dataIn.data_cf[acf_ind,:], self.dataIn.data_cf[ccf_ind,:,:])
158 172 self.dataOut.normFactor = (self.dataIn.normFactor[acf_ind,:], self.dataIn.normFactor[ccf_ind,:])
159 173 self.dataOut.groupList = (acf_pairs, ccf_pairs)
160
174
161 175 self.dataOut.abscissaList = self.dataIn.lagRange
162 176 self.dataOut.noise = self.dataIn.noise
163 177 self.dataOut.data_SNR = self.dataIn.SNR
164 178 self.dataOut.flagNoData = False
165 179 self.dataOut.nAvg = self.dataIn.nAvg
166
180
167 181 #---------------------- Parameters Data ---------------------------
168
182
169 183 if self.dataIn.type == "Parameters":
170 184 self.dataOut.copy(self.dataIn)
171 185 self.dataOut.flagNoData = False
172
186
173 187 return True
174
188
175 189 self.__updateObjFromInput()
176 190 self.dataOut.utctimeInit = self.dataIn.utctime
177 191 self.dataOut.paramInterval = self.dataIn.timeInterval
178
192
179 193 return
180 194
181 195
182 196 def target(tups):
183
197
184 198 obj, args = tups
185
199
186 200 return obj.FitGau(args)
187
188
201
202
189 203 class SpectralFilters(Operation):
190
204
191 205 '''This class allows the Rainfall / Wind Selection for CLAIRE RADAR
192
206
193 207 LimitR : It is the limit in m/s of Rainfall
194 208 LimitW : It is the limit in m/s for Winds
195
209
196 210 Input:
197
211
198 212 self.dataOut.data_pre : SPC and CSPC
199 213 self.dataOut.spc_range : To select wind and rainfall velocities
200
214
201 215 Affected:
202
216
203 217 self.dataOut.data_pre : It is used for the new SPC and CSPC ranges of wind
204 self.dataOut.spcparam_range : Used in SpcParamPlot
218 self.dataOut.spcparam_range : Used in SpcParamPlot
205 219 self.dataOut.SPCparam : Used in PrecipitationProc
206
207
220
221
208 222 '''
209
223
210 224 def __init__(self):
211 225 Operation.__init__(self)
212 226 self.i=0
213
214 def run(self, dataOut, PositiveLimit=1.5, NegativeLimit=2.5):
215
216
217 #Limite de vientos
227
228 def run(self, dataOut, PositiveLimit=1.5, NegativeLimit=2.5):
229
230
231 #Limite de vientos
218 232 LimitR = PositiveLimit
219 233 LimitN = NegativeLimit
220
234
221 235 self.spc = dataOut.data_pre[0].copy()
222 236 self.cspc = dataOut.data_pre[1].copy()
223
237
224 238 self.Num_Hei = self.spc.shape[2]
225 239 self.Num_Bin = self.spc.shape[1]
226 240 self.Num_Chn = self.spc.shape[0]
227
241
228 242 VelRange = dataOut.spc_range[2]
229 243 TimeRange = dataOut.spc_range[1]
230 244 FrecRange = dataOut.spc_range[0]
231
245
232 246 Vmax= 2*numpy.max(dataOut.spc_range[2])
233 247 Tmax= 2*numpy.max(dataOut.spc_range[1])
234 248 Fmax= 2*numpy.max(dataOut.spc_range[0])
235
249
236 250 Breaker1R=VelRange[numpy.abs(VelRange-(-LimitN)).argmin()]
237 251 Breaker1R=numpy.where(VelRange == Breaker1R)
238
239 Delta = self.Num_Bin/2 - Breaker1R[0]
240
241
252
253 Delta = self.Num_Bin/2 - Breaker1R[0]
254
255
242 256 '''Reacomodando SPCrange'''
243 257
244 258 VelRange=numpy.roll(VelRange,-(int(self.Num_Bin/2)) ,axis=0)
245
259
246 260 VelRange[-(int(self.Num_Bin/2)):]+= Vmax
247
261
248 262 FrecRange=numpy.roll(FrecRange,-(int(self.Num_Bin/2)),axis=0)
249
263
250 264 FrecRange[-(int(self.Num_Bin/2)):]+= Fmax
251
265
252 266 TimeRange=numpy.roll(TimeRange,-(int(self.Num_Bin/2)),axis=0)
253
267
254 268 TimeRange[-(int(self.Num_Bin/2)):]+= Tmax
255
269
256 270 ''' ------------------ '''
257
271
258 272 Breaker2R=VelRange[numpy.abs(VelRange-(LimitR)).argmin()]
259 273 Breaker2R=numpy.where(VelRange == Breaker2R)
260
261
274
275
262 276 SPCroll = numpy.roll(self.spc,-(int(self.Num_Bin/2)) ,axis=1)
263
277
264 278 SPCcut = SPCroll.copy()
265 279 for i in range(self.Num_Chn):
266
280
267 281 SPCcut[i,0:int(Breaker2R[0]),:] = dataOut.noise[i]
268 282 SPCcut[i,-int(Delta):,:] = dataOut.noise[i]
269
283
270 284 SPCcut[i]=SPCcut[i]- dataOut.noise[i]
271 285 SPCcut[ numpy.where( SPCcut<0 ) ] = 1e-20
272
286
273 287 SPCroll[i]=SPCroll[i]-dataOut.noise[i]
274 288 SPCroll[ numpy.where( SPCroll<0 ) ] = 1e-20
275
289
276 290 SPC_ch1 = SPCroll
277
291
278 292 SPC_ch2 = SPCcut
279
293
280 294 SPCparam = (SPC_ch1, SPC_ch2, self.spc)
281 dataOut.SPCparam = numpy.asarray(SPCparam)
282
283
295 dataOut.SPCparam = numpy.asarray(SPCparam)
296
297
284 298 dataOut.spcparam_range=numpy.zeros([self.Num_Chn,self.Num_Bin+1])
285
299
286 300 dataOut.spcparam_range[2]=VelRange
287 301 dataOut.spcparam_range[1]=TimeRange
288 302 dataOut.spcparam_range[0]=FrecRange
289 303 return dataOut
290
304
291 305 class GaussianFit(Operation):
292
306
293 307 '''
294 Function that fit of one and two generalized gaussians (gg) based
295 on the PSD shape across an "power band" identified from a cumsum of
308 Function that fit of one and two generalized gaussians (gg) based
309 on the PSD shape across an "power band" identified from a cumsum of
296 310 the measured spectrum - noise.
297
311
298 312 Input:
299 313 self.dataOut.data_pre : SelfSpectra
300
314
301 315 Output:
302 316 self.dataOut.SPCparam : SPC_ch1, SPC_ch2
303
317
304 318 '''
305 319 def __init__(self):
306 320 Operation.__init__(self)
307 321 self.i=0
308
309
322
323
310 324 def run(self, dataOut, num_intg=7, pnoise=1., SNRlimit=-9): #num_intg: Incoherent integrations, pnoise: Noise, vel_arr: range of velocities, similar to the ftt points
311 325 """This routine will find a couple of generalized Gaussians to a power spectrum
312 326 input: spc
313 327 output:
314 328 Amplitude0,shift0,width0,p0,Amplitude1,shift1,width1,p1,noise
315 329 """
316
330
317 331 self.spc = dataOut.data_pre[0].copy()
318 332 self.Num_Hei = self.spc.shape[2]
319 333 self.Num_Bin = self.spc.shape[1]
320 334 self.Num_Chn = self.spc.shape[0]
321 335 Vrange = dataOut.abscissaList
322
336
323 337 GauSPC = numpy.empty([self.Num_Chn,self.Num_Bin,self.Num_Hei])
324 338 SPC_ch1 = numpy.empty([self.Num_Bin,self.Num_Hei])
325 339 SPC_ch2 = numpy.empty([self.Num_Bin,self.Num_Hei])
326 340 SPC_ch1[:] = numpy.NaN
327 341 SPC_ch2[:] = numpy.NaN
328 342
329
343
330 344 start_time = time.time()
331
345
332 346 noise_ = dataOut.spc_noise[0].copy()
333
334
335 pool = Pool(processes=self.Num_Chn)
347
348
349 pool = Pool(processes=self.Num_Chn)
336 350 args = [(Vrange, Ch, pnoise, noise_, num_intg, SNRlimit) for Ch in range(self.Num_Chn)]
337 objs = [self for __ in range(self.Num_Chn)]
338 attrs = list(zip(objs, args))
351 objs = [self for __ in range(self.Num_Chn)]
352 attrs = list(zip(objs, args))
339 353 gauSPC = pool.map(target, attrs)
340 354 dataOut.SPCparam = numpy.asarray(SPCparam)
341
355
342 356 ''' Parameters:
343 357 1. Amplitude
344 358 2. Shift
345 359 3. Width
346 360 4. Power
347 361 '''
348
362
349 363 def FitGau(self, X):
350
364
351 365 Vrange, ch, pnoise, noise_, num_intg, SNRlimit = X
352
366
353 367 SPCparam = []
354 368 SPC_ch1 = numpy.empty([self.Num_Bin,self.Num_Hei])
355 369 SPC_ch2 = numpy.empty([self.Num_Bin,self.Num_Hei])
356 370 SPC_ch1[:] = 0#numpy.NaN
357 371 SPC_ch2[:] = 0#numpy.NaN
358
359
360
372
373
374
361 375 for ht in range(self.Num_Hei):
362
363
376
377
364 378 spc = numpy.asarray(self.spc)[ch,:,ht]
365
379
366 380 #############################################
367 381 # normalizing spc and noise
368 382 # This part differs from gg1
@@ -370,60 +384,60 class GaussianFit(Operation):
370 384 #spc = spc / spc_norm_max
371 385 pnoise = pnoise #/ spc_norm_max
372 386 #############################################
373
387
374 388 fatspectra=1.0
375
389
376 390 wnoise = noise_ #/ spc_norm_max
377 391 #wnoise,stdv,i_max,index =enoise(spc,num_intg) #noise estimate using Hildebrand Sekhon, only wnoise is used
378 #if wnoise>1.1*pnoise: # to be tested later
392 #if wnoise>1.1*pnoise: # to be tested later
379 393 # wnoise=pnoise
380 noisebl=wnoise*0.9;
394 noisebl=wnoise*0.9;
381 395 noisebh=wnoise*1.1
382 396 spc=spc-wnoise
383
397
384 398 minx=numpy.argmin(spc)
385 #spcs=spc.copy()
399 #spcs=spc.copy()
386 400 spcs=numpy.roll(spc,-minx)
387 401 cum=numpy.cumsum(spcs)
388 402 tot_noise=wnoise * self.Num_Bin #64;
389
403
390 404 snr = sum(spcs)/tot_noise
391 405 snrdB=10.*numpy.log10(snr)
392
406
393 407 if snrdB < SNRlimit :
394 408 snr = numpy.NaN
395 409 SPC_ch1[:,ht] = 0#numpy.NaN
396 410 SPC_ch1[:,ht] = 0#numpy.NaN
397 411 SPCparam = (SPC_ch1,SPC_ch2)
398 412 continue
399
400
413
414
401 415 #if snrdB<-18 or numpy.isnan(snrdB) or num_intg<4:
402 416 # return [None,]*4,[None,]*4,None,snrdB,None,None,[None,]*5,[None,]*9,None
403
404 cummax=max(cum);
417
418 cummax=max(cum);
405 419 epsi=0.08*fatspectra # cumsum to narrow down the energy region
406 cumlo=cummax*epsi;
420 cumlo=cummax*epsi;
407 421 cumhi=cummax*(1-epsi)
408 422 powerindex=numpy.array(numpy.where(numpy.logical_and(cum>cumlo, cum<cumhi))[0])
409
410
423
424
411 425 if len(powerindex) < 1:# case for powerindex 0
412 426 continue
413 427 powerlo=powerindex[0]
414 428 powerhi=powerindex[-1]
415 429 powerwidth=powerhi-powerlo
416
430
417 431 firstpeak=powerlo+powerwidth/10.# first gaussian energy location
418 432 secondpeak=powerhi-powerwidth/10.#second gaussian energy location
419 433 midpeak=(firstpeak+secondpeak)/2.
420 434 firstamp=spcs[int(firstpeak)]
421 435 secondamp=spcs[int(secondpeak)]
422 436 midamp=spcs[int(midpeak)]
423
437
424 438 x=numpy.arange( self.Num_Bin )
425 439 y_data=spc+wnoise
426
440
427 441 ''' single Gaussian '''
428 442 shift0=numpy.mod(midpeak+minx, self.Num_Bin )
429 443 width0=powerwidth/4.#Initialization entire power of spectrum divided by 4
@@ -432,10 +446,10 class GaussianFit(Operation):
432 446 state0=[shift0,width0,amplitude0,power0,wnoise]
433 447 bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth),(0,None),(0.5,3.),(noisebl,noisebh))
434 448 lsq1=fmin_l_bfgs_b(self.misfit1,state0,args=(y_data,x,num_intg),bounds=bnds,approx_grad=True)
435
436 chiSq1=lsq1[1];
437 449
438
450 chiSq1=lsq1[1];
451
452
439 453 if fatspectra<1.0 and powerwidth<4:
440 454 choice=0
441 455 Amplitude0=lsq1[0][2]
@@ -449,31 +463,31 class GaussianFit(Operation):
449 463 noise=lsq1[0][4]
450 464 #return (numpy.array([shift0,width0,Amplitude0,p0]),
451 465 # numpy.array([shift1,width1,Amplitude1,p1]),noise,snrdB,chiSq1,6.,sigmas1,[None,]*9,choice)
452
466
453 467 ''' two gaussians '''
454 468 #shift0=numpy.mod(firstpeak+minx,64); shift1=numpy.mod(secondpeak+minx,64)
455 shift0=numpy.mod(firstpeak+minx, self.Num_Bin );
469 shift0=numpy.mod(firstpeak+minx, self.Num_Bin );
456 470 shift1=numpy.mod(secondpeak+minx, self.Num_Bin )
457 width0=powerwidth/6.;
471 width0=powerwidth/6.;
458 472 width1=width0
459 power0=2.;
473 power0=2.;
460 474 power1=power0
461 amplitude0=firstamp;
475 amplitude0=firstamp;
462 476 amplitude1=secondamp
463 477 state0=[shift0,width0,amplitude0,power0,shift1,width1,amplitude1,power1,wnoise]
464 478 #bnds=((0,63),(1,powerwidth/2.),(0,None),(0.5,3.),(0,63),(1,powerwidth/2.),(0,None),(0.5,3.),(noisebl,noisebh))
465 479 bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth/2.),(0,None),(0.5,3.),( 0,(self.Num_Bin-1)),(1,powerwidth/2.),(0,None),(0.5,3.),(noisebl,noisebh))
466 480 #bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth/2.),(0,None),(0.5,3.),( 0,(self.Num_Bin-1)),(1,powerwidth/2.),(0,None),(0.5,3.),(0.1,0.5))
467
481
468 482 lsq2 = fmin_l_bfgs_b( self.misfit2 , state0 , args=(y_data,x,num_intg) , bounds=bnds , approx_grad=True )
469
470
471 chiSq2=lsq2[1];
472
473
474
483
484
485 chiSq2=lsq2[1];
486
487
488
475 489 oneG=(chiSq1<5 and chiSq1/chiSq2<2.0) and (abs(lsq2[0][0]-lsq2[0][4])<(lsq2[0][1]+lsq2[0][5])/3. or abs(lsq2[0][0]-lsq2[0][4])<10)
476
490
477 491 if snrdB>-12: # when SNR is strong pick the peak with least shift (LOS velocity) error
478 492 if oneG:
479 493 choice=0
@@ -481,10 +495,10 class GaussianFit(Operation):
481 495 w1=lsq2[0][1]; w2=lsq2[0][5]
482 496 a1=lsq2[0][2]; a2=lsq2[0][6]
483 497 p1=lsq2[0][3]; p2=lsq2[0][7]
484 s1=(2**(1+1./p1))*scipy.special.gamma(1./p1)/p1;
498 s1=(2**(1+1./p1))*scipy.special.gamma(1./p1)/p1;
485 499 s2=(2**(1+1./p2))*scipy.special.gamma(1./p2)/p2;
486 500 gp1=a1*w1*s1; gp2=a2*w2*s2 # power content of each ggaussian with proper p scaling
487
501
488 502 if gp1>gp2:
489 503 if a1>0.7*a2:
490 504 choice=1
@@ -499,157 +513,157 class GaussianFit(Operation):
499 513 choice=numpy.argmax([a1,a2])+1
500 514 #else:
501 515 #choice=argmin([std2a,std2b])+1
502
516
503 517 else: # with low SNR go to the most energetic peak
504 518 choice=numpy.argmax([lsq1[0][2]*lsq1[0][1],lsq2[0][2]*lsq2[0][1],lsq2[0][6]*lsq2[0][5]])
505
506
507 shift0=lsq2[0][0];
519
520
521 shift0=lsq2[0][0];
508 522 vel0=Vrange[0] + shift0*(Vrange[1]-Vrange[0])
509 shift1=lsq2[0][4];
523 shift1=lsq2[0][4];
510 524 vel1=Vrange[0] + shift1*(Vrange[1]-Vrange[0])
511
525
512 526 max_vel = 1.0
513
527
514 528 #first peak will be 0, second peak will be 1
515 529 if vel0 > -1.0 and vel0 < max_vel : #first peak is in the correct range
516 530 shift0=lsq2[0][0]
517 531 width0=lsq2[0][1]
518 532 Amplitude0=lsq2[0][2]
519 533 p0=lsq2[0][3]
520
534
521 535 shift1=lsq2[0][4]
522 536 width1=lsq2[0][5]
523 537 Amplitude1=lsq2[0][6]
524 538 p1=lsq2[0][7]
525 noise=lsq2[0][8]
539 noise=lsq2[0][8]
526 540 else:
527 541 shift1=lsq2[0][0]
528 542 width1=lsq2[0][1]
529 543 Amplitude1=lsq2[0][2]
530 544 p1=lsq2[0][3]
531
545
532 546 shift0=lsq2[0][4]
533 547 width0=lsq2[0][5]
534 548 Amplitude0=lsq2[0][6]
535 p0=lsq2[0][7]
536 noise=lsq2[0][8]
537
549 p0=lsq2[0][7]
550 noise=lsq2[0][8]
551
538 552 if Amplitude0<0.05: # in case the peak is noise
539 shift0,width0,Amplitude0,p0 = [0,0,0,0]#4*[numpy.NaN]
553 shift0,width0,Amplitude0,p0 = [0,0,0,0]#4*[numpy.NaN]
540 554 if Amplitude1<0.05:
541 shift1,width1,Amplitude1,p1 = [0,0,0,0]#4*[numpy.NaN]
542
543
555 shift1,width1,Amplitude1,p1 = [0,0,0,0]#4*[numpy.NaN]
556
557
544 558 SPC_ch1[:,ht] = noise + Amplitude0*numpy.exp(-0.5*(abs(x-shift0))/width0)**p0
545 559 SPC_ch2[:,ht] = noise + Amplitude1*numpy.exp(-0.5*(abs(x-shift1))/width1)**p1
546 560 SPCparam = (SPC_ch1,SPC_ch2)
547
548
561
562
549 563 return GauSPC
550
564
551 565 def y_model1(self,x,state):
552 566 shift0,width0,amplitude0,power0,noise=state
553 567 model0=amplitude0*numpy.exp(-0.5*abs((x-shift0)/width0)**power0)
554
568
555 569 model0u=amplitude0*numpy.exp(-0.5*abs((x-shift0- self.Num_Bin )/width0)**power0)
556
570
557 571 model0d=amplitude0*numpy.exp(-0.5*abs((x-shift0+ self.Num_Bin )/width0)**power0)
558 572 return model0+model0u+model0d+noise
559
560 def y_model2(self,x,state): #Equation for two generalized Gaussians with Nyquist
573
574 def y_model2(self,x,state): #Equation for two generalized Gaussians with Nyquist
561 575 shift0,width0,amplitude0,power0,shift1,width1,amplitude1,power1,noise=state
562 576 model0=amplitude0*numpy.exp(-0.5*abs((x-shift0)/width0)**power0)
563
577
564 578 model0u=amplitude0*numpy.exp(-0.5*abs((x-shift0- self.Num_Bin )/width0)**power0)
565
579
566 580 model0d=amplitude0*numpy.exp(-0.5*abs((x-shift0+ self.Num_Bin )/width0)**power0)
567 581 model1=amplitude1*numpy.exp(-0.5*abs((x-shift1)/width1)**power1)
568
582
569 583 model1u=amplitude1*numpy.exp(-0.5*abs((x-shift1- self.Num_Bin )/width1)**power1)
570
584
571 585 model1d=amplitude1*numpy.exp(-0.5*abs((x-shift1+ self.Num_Bin )/width1)**power1)
572 586 return model0+model0u+model0d+model1+model1u+model1d+noise
573
574 def misfit1(self,state,y_data,x,num_intg): # This function compares how close real data is with the model data, the close it is, the better it is.
587
588 def misfit1(self,state,y_data,x,num_intg): # This function compares how close real data is with the model data, the close it is, the better it is.
575 589
576 590 return num_intg*sum((numpy.log(y_data)-numpy.log(self.y_model1(x,state)))**2)#/(64-5.) # /(64-5.) can be commented
577
591
578 592 def misfit2(self,state,y_data,x,num_intg):
579 593 return num_intg*sum((numpy.log(y_data)-numpy.log(self.y_model2(x,state)))**2)#/(64-9.)
580
581
594
595
582 596
583 597 class PrecipitationProc(Operation):
584
598
585 599 '''
586 600 Operator that estimates Reflectivity factor (Z), and estimates rainfall Rate (R)
587
588 Input:
601
602 Input:
589 603 self.dataOut.data_pre : SelfSpectra
590
591 Output:
592
593 self.dataOut.data_output : Reflectivity factor, rainfall Rate
594
595
596 Parameters affected:
604
605 Output:
606
607 self.dataOut.data_output : Reflectivity factor, rainfall Rate
608
609
610 Parameters affected:
597 611 '''
598
612
599 613 def __init__(self):
600 614 Operation.__init__(self)
601 615 self.i=0
602
603
616
617
604 618 def gaus(self,xSamples,Amp,Mu,Sigma):
605 619 return ( Amp / ((2*numpy.pi)**0.5 * Sigma) ) * numpy.exp( -( xSamples - Mu )**2 / ( 2 * (Sigma**2) ))
606
607
608
620
621
622
609 623 def Moments(self, ySamples, xSamples):
610 624 Pot = numpy.nansum( ySamples ) # Potencia, momento 0
611 625 yNorm = ySamples / Pot
612
626
613 627 Vr = numpy.nansum( yNorm * xSamples ) # Velocidad radial, mu, corrimiento doppler, primer momento
614 Sigma2 = abs(numpy.nansum( yNorm * ( xSamples - Vr )**2 )) # Segundo Momento
628 Sigma2 = abs(numpy.nansum( yNorm * ( xSamples - Vr )**2 )) # Segundo Momento
615 629 Desv = Sigma2**0.5 # Desv. Estandar, Ancho espectral
616
617 return numpy.array([Pot, Vr, Desv])
618
619 def run(self, dataOut, radar=None, Pt=5000, Gt=295.1209, Gr=70.7945, Lambda=0.6741, aL=2.5118,
630
631 return numpy.array([Pot, Vr, Desv])
632
633 def run(self, dataOut, radar=None, Pt=5000, Gt=295.1209, Gr=70.7945, Lambda=0.6741, aL=2.5118,
620 634 tauW=4e-06, ThetaT=0.1656317, ThetaR=0.36774087, Km = 0.93, Altitude=3350):
621
622
635
636
623 637 Velrange = dataOut.spcparam_range[2]
624 638 FrecRange = dataOut.spcparam_range[0]
625
639
626 640 dV= Velrange[1]-Velrange[0]
627 641 dF= FrecRange[1]-FrecRange[0]
628
642
629 643 if radar == "MIRA35C" :
630
644
631 645 self.spc = dataOut.data_pre[0].copy()
632 646 self.Num_Hei = self.spc.shape[2]
633 647 self.Num_Bin = self.spc.shape[1]
634 648 self.Num_Chn = self.spc.shape[0]
635 649 Ze = self.dBZeMODE2(dataOut)
636
650
637 651 else:
638
652
639 653 self.spc = dataOut.SPCparam[1].copy() #dataOut.data_pre[0].copy() #
640
654
641 655 """NOTA SE DEBE REMOVER EL RANGO DEL PULSO TX"""
642
643 self.spc[:,:,0:7]= numpy.NaN
644
656
657 self.spc[:,:,0:7]= numpy.NaN
658
645 659 """##########################################"""
646
660
647 661 self.Num_Hei = self.spc.shape[2]
648 662 self.Num_Bin = self.spc.shape[1]
649 663 self.Num_Chn = self.spc.shape[0]
650
664
651 665 ''' Se obtiene la constante del RADAR '''
652
666
653 667 self.Pt = Pt
654 668 self.Gt = Gt
655 669 self.Gr = Gr
@@ -658,30 +672,30 class PrecipitationProc(Operation):
658 672 self.tauW = tauW
659 673 self.ThetaT = ThetaT
660 674 self.ThetaR = ThetaR
661
675
662 676 Numerator = ( (4*numpy.pi)**3 * aL**2 * 16 * numpy.log(2) )
663 677 Denominator = ( Pt * Gt * Gr * Lambda**2 * SPEED_OF_LIGHT * tauW * numpy.pi * ThetaT * ThetaR)
664 678 RadarConstant = 10e-26 * Numerator / Denominator #
665
679
666 680 ''' ============================= '''
667
668 self.spc[0] = (self.spc[0]-dataOut.noise[0])
669 self.spc[1] = (self.spc[1]-dataOut.noise[1])
670 self.spc[2] = (self.spc[2]-dataOut.noise[2])
671
681
682 self.spc[0] = (self.spc[0]-dataOut.noise[0])
683 self.spc[1] = (self.spc[1]-dataOut.noise[1])
684 self.spc[2] = (self.spc[2]-dataOut.noise[2])
685
672 686 self.spc[ numpy.where(self.spc < 0)] = 0
673
674 SPCmean = (numpy.mean(self.spc,0) - numpy.mean(dataOut.noise))
687
688 SPCmean = (numpy.mean(self.spc,0) - numpy.mean(dataOut.noise))
675 689 SPCmean[ numpy.where(SPCmean < 0)] = 0
676
690
677 691 ETAn = numpy.zeros([self.Num_Bin,self.Num_Hei])
678 692 ETAv = numpy.zeros([self.Num_Bin,self.Num_Hei])
679 693 ETAd = numpy.zeros([self.Num_Bin,self.Num_Hei])
680
694
681 695 Pr = SPCmean[:,:]
682
696
683 697 VelMeteoro = numpy.mean(SPCmean,axis=0)
684
698
685 699 D_range = numpy.zeros([self.Num_Bin,self.Num_Hei])
686 700 SIGMA = numpy.zeros([self.Num_Bin,self.Num_Hei])
687 701 N_dist = numpy.zeros([self.Num_Bin,self.Num_Hei])
@@ -690,102 +704,102 class PrecipitationProc(Operation):
690 704 Z = numpy.zeros(self.Num_Hei)
691 705 Ze = numpy.zeros(self.Num_Hei)
692 706 RR = numpy.zeros(self.Num_Hei)
693
707
694 708 Range = dataOut.heightList*1000.
695
709
696 710 for R in range(self.Num_Hei):
697
711
698 712 h = Range[R] + Altitude #Range from ground to radar pulse altitude
699 713 del_V[R] = 1 + 3.68 * 10**-5 * h + 1.71 * 10**-9 * h**2 #Density change correction for velocity
700
714
701 715 D_range[:,R] = numpy.log( (9.65 - (Velrange[0:self.Num_Bin] / del_V[R])) / 10.3 ) / -0.6 #Diameter range [m]x10**-3
702
716
703 717 '''NOTA: ETA(n) dn = ETA(f) df
704
718
705 719 dn = 1 Diferencial de muestreo
706 720 df = ETA(n) / ETA(f)
707
721
708 722 '''
709
723
710 724 ETAn[:,R] = RadarConstant * Pr[:,R] * (Range[R] )**2 #Reflectivity (ETA)
711
725
712 726 ETAv[:,R]=ETAn[:,R]/dV
713
727
714 728 ETAd[:,R]=ETAv[:,R]*6.18*exp(-0.6*D_range[:,R])
715
729
716 730 SIGMA[:,R] = Km * (D_range[:,R] * 1e-3 )**6 * numpy.pi**5 / Lambda**4 #Equivalent Section of drops (sigma)
717
718 N_dist[:,R] = ETAn[:,R] / SIGMA[:,R]
719
731
732 N_dist[:,R] = ETAn[:,R] / SIGMA[:,R]
733
720 734 DMoments = self.Moments(Pr[:,R], Velrange[0:self.Num_Bin])
721
735
722 736 try:
723 737 popt01,pcov = curve_fit(self.gaus, Velrange[0:self.Num_Bin] , Pr[:,R] , p0=DMoments)
724 except:
738 except:
725 739 popt01=numpy.zeros(3)
726 740 popt01[1]= DMoments[1]
727
741
728 742 if popt01[1]<0 or popt01[1]>20:
729 743 popt01[1]=numpy.NaN
730
731
744
745
732 746 V_mean[R]=popt01[1]
733
747
734 748 Z[R] = numpy.nansum( N_dist[:,R] * (D_range[:,R])**6 )#*10**-18
735
749
736 750 RR[R] = 0.0006*numpy.pi * numpy.nansum( D_range[:,R]**3 * N_dist[:,R] * Velrange[0:self.Num_Bin] ) #Rainfall rate
737
751
738 752 Ze[R] = (numpy.nansum( ETAn[:,R]) * Lambda**4) / ( 10**-18*numpy.pi**5 * Km)
739
740
741
753
754
755
742 756 RR2 = (Z/200)**(1/1.6)
743 757 dBRR = 10*numpy.log10(RR)
744 758 dBRR2 = 10*numpy.log10(RR2)
745
759
746 760 dBZe = 10*numpy.log10(Ze)
747 761 dBZ = 10*numpy.log10(Z)
748
762
749 763 dataOut.data_output = RR[8]
750 764 dataOut.data_param = numpy.ones([3,self.Num_Hei])
751 765 dataOut.channelList = [0,1,2]
752
766
753 767 dataOut.data_param[0]=dBZ
754 768 dataOut.data_param[1]=V_mean
755 769 dataOut.data_param[2]=RR
756 770
757 771 return dataOut
758
772
759 773 def dBZeMODE2(self, dataOut): # Processing for MIRA35C
760
774
761 775 NPW = dataOut.NPW
762 776 COFA = dataOut.COFA
763
777
764 778 SNR = numpy.array([self.spc[0,:,:] / NPW[0]]) #, self.spc[1,:,:] / NPW[1]])
765 779 RadarConst = dataOut.RadarConst
766 780 #frequency = 34.85*10**9
767
781
768 782 ETA = numpy.zeros(([self.Num_Chn ,self.Num_Hei]))
769 783 data_output = numpy.ones([self.Num_Chn , self.Num_Hei])*numpy.NaN
770
784
771 785 ETA = numpy.sum(SNR,1)
772
786
773 787 ETA = numpy.where(ETA is not 0. , ETA, numpy.NaN)
774
788
775 789 Ze = numpy.ones([self.Num_Chn, self.Num_Hei] )
776
790
777 791 for r in range(self.Num_Hei):
778
792
779 793 Ze[0,r] = ( ETA[0,r] ) * COFA[0,r][0] * RadarConst * ((r/5000.)**2)
780 794 #Ze[1,r] = ( ETA[1,r] ) * COFA[1,r][0] * RadarConst * ((r/5000.)**2)
781
795
782 796 return Ze
783
797
784 798 # def GetRadarConstant(self):
785 #
786 # """
799 #
800 # """
787 801 # Constants:
788 #
802 #
789 803 # Pt: Transmission Power dB 5kW 5000
790 804 # Gt: Transmission Gain dB 24.7 dB 295.1209
791 805 # Gr: Reception Gain dB 18.5 dB 70.7945
@@ -794,55 +808,55 class PrecipitationProc(Operation):
794 808 # tauW: Width of transmission pulse s 4us 4e-6
795 809 # ThetaT: Transmission antenna bean angle rad 0.1656317 rad 0.1656317
796 810 # ThetaR: Reception antenna beam angle rad 0.36774087 rad 0.36774087
797 #
811 #
798 812 # """
799 #
813 #
800 814 # Numerator = ( (4*numpy.pi)**3 * aL**2 * 16 * numpy.log(2) )
801 815 # Denominator = ( Pt * Gt * Gr * Lambda**2 * SPEED_OF_LIGHT * TauW * numpy.pi * ThetaT * TheraR)
802 816 # RadarConstant = Numerator / Denominator
803 #
817 #
804 818 # return RadarConstant
805
806
807
808 class FullSpectralAnalysis(Operation):
809
819
820
821
822 class FullSpectralAnalysis(Operation):
823
810 824 """
811 825 Function that implements Full Spectral Analysis technique.
812
813 Input:
826
827 Input:
814 828 self.dataOut.data_pre : SelfSpectra and CrossSpectra data
815 829 self.dataOut.groupList : Pairlist of channels
816 830 self.dataOut.ChanDist : Physical distance between receivers
817
818
819 Output:
820
821 self.dataOut.data_output : Zonal wind, Meridional wind and Vertical wind
822
823
831
832
833 Output:
834
835 self.dataOut.data_output : Zonal wind, Meridional wind and Vertical wind
836
837
824 838 Parameters affected: Winds, height range, SNR
825
839
826 840 """
827 841 def run(self, dataOut, Xi01=None, Xi02=None, Xi12=None, Eta01=None, Eta02=None, Eta12=None, SNRlimit=7, minheight=None, maxheight=None):
828
829 self.indice=int(numpy.random.rand()*1000)
830
842
843 self.indice=int(numpy.random.rand()*1000)
844
831 845 spc = dataOut.data_pre[0].copy()
832 846 cspc = dataOut.data_pre[1]
833
847
834 848 """Erick: NOTE THE RANGE OF THE PULSE TX MUST BE REMOVED"""
835 849
836 850 SNRspc = spc.copy()
837 851 SNRspc[:,:,0:7]= numpy.NaN
838
852
839 853 """##########################################"""
840
841
854
855
842 856 nChannel = spc.shape[0]
843 857 nProfiles = spc.shape[1]
844 858 nHeights = spc.shape[2]
845
859
846 860 # first_height = 0.75 #km (ref: data header 20170822)
847 861 # resolution_height = 0.075 #km
848 862 '''
@@ -866,37 +880,37 class FullSpectralAnalysis(Operation):
866 880 ChanDist = dataOut.ChanDist
867 881 else:
868 882 ChanDist = numpy.array([[Xi01, Eta01],[Xi02,Eta02],[Xi12,Eta12]])
869
883
870 884 FrecRange = dataOut.spc_range[0]
871
885
872 886 data_SNR=numpy.zeros([nProfiles])
873 887 noise = dataOut.noise
874
888
875 889 dataOut.data_SNR = (numpy.mean(SNRspc,axis=1)- noise[0]) / noise[0]
876
890
877 891 dataOut.data_SNR[numpy.where( dataOut.data_SNR <0 )] = 1e-20
878
879
892
893
880 894 data_output=numpy.ones([spc.shape[0],spc.shape[2]])*numpy.NaN
881
895
882 896 velocityX=[]
883 897 velocityY=[]
884 velocityV=[]
885
898 velocityV=[]
899
886 900 dbSNR = 10*numpy.log10(dataOut.data_SNR)
887 901 dbSNR = numpy.average(dbSNR,0)
888
902
889 903 '''***********************************************WIND ESTIMATION**************************************'''
890
904
891 905 for Height in range(nHeights):
892
893 if Height >= range_min and Height < range_max:
894 # error_code unused, yet maybe useful for future analysis.
906
907 if Height >= range_min and Height < range_max:
908 # error_code unused, yet maybe useful for future analysis.
895 909 [Vzon,Vmer,Vver, error_code] = self.WindEstimation(spc[:,:,Height], cspc[:,:,Height], pairsList, ChanDist, Height, noise, dataOut.spc_range, dbSNR[Height], SNRlimit)
896 910 else:
897 911 Vzon,Vmer,Vver = 0., 0., numpy.NaN
898
899
912
913
900 914 if abs(Vzon) < 100. and abs(Vzon) > 0. and abs(Vmer) < 100. and abs(Vmer) > 0.:
901 915 velocityX=numpy.append(velocityX, Vzon)
902 916 velocityY=numpy.append(velocityY, -Vmer)
@@ -904,33 +918,33 class FullSpectralAnalysis(Operation):
904 918 else:
905 919 velocityX=numpy.append(velocityX, numpy.NaN)
906 920 velocityY=numpy.append(velocityY, numpy.NaN)
907
921
908 922 if dbSNR[Height] > SNRlimit:
909 923 velocityV=numpy.append(velocityV, -Vver) # reason for this minus sign -> convention? (taken from Ericks version)
910 924 else:
911 925 velocityV=numpy.append(velocityV, numpy.NaN)
912
913
926
927
914 928 '''Change the numpy.array (velocityX) sign when trying to process BLTR data (Erick)'''
915 data_output[0] = numpy.array(velocityX)
916 data_output[1] = numpy.array(velocityY)
929 data_output[0] = numpy.array(velocityX)
930 data_output[1] = numpy.array(velocityY)
917 931 data_output[2] = velocityV
918
919
932
933
920 934 dataOut.data_output = data_output
921
935
922 936 return dataOut
923
937
924 938
925 939 def moving_average(self,x, N=2):
926 940 """ convolution for smoothenig data. note that last N-1 values are convolution with zeroes """
927 941 return numpy.convolve(x, numpy.ones((N,))/N)[(N-1):]
928
942
929 943 def gaus(self,xSamples,Amp,Mu,Sigma):
930 944 return ( Amp / ((2*numpy.pi)**0.5 * Sigma) ) * numpy.exp( -( xSamples - Mu )**2 / ( 2 * (Sigma**2) ))
931
945
932 946 def Moments(self, ySamples, xSamples):
933 '''***
947 '''***
934 948 Variables corresponding to moments of distribution.
935 949 Also used as initial coefficients for curve_fit.
936 950 Vr was corrected. Only a velocity when x is velocity, of course.
@@ -939,9 +953,9 class FullSpectralAnalysis(Operation):
939 953 yNorm = ySamples / Pot
940 954 x_range = (numpy.max(xSamples)-numpy.min(xSamples))
941 955 Vr = numpy.nansum( yNorm * xSamples )*x_range/len(xSamples) # Velocidad radial, mu, corrimiento doppler, primer momento
942 Sigma2 = abs(numpy.nansum( yNorm * ( xSamples - Vr )**2 )) # Segundo Momento
956 Sigma2 = abs(numpy.nansum( yNorm * ( xSamples - Vr )**2 )) # Segundo Momento
943 957 Desv = Sigma2**0.5 # Desv. Estandar, Ancho espectral
944
958
945 959 return numpy.array([Pot, Vr, Desv])
946 960
947 961 def StopWindEstimation(self, error_code):
@@ -954,7 +968,7 class FullSpectralAnalysis(Operation):
954 968 return Vzon, Vmer, Vver, error_code
955 969
956 970 def AntiAliasing(self, interval, maxstep):
957 """
971 """
958 972 function to prevent errors from aliased values when computing phaseslope
959 973 """
960 974 antialiased = numpy.zeros(len(interval))*0.0
@@ -964,8 +978,8 class FullSpectralAnalysis(Operation):
964 978
965 979 for i in range(1,len(antialiased)):
966 980
967 step = interval[i] - interval[i-1]
968
981 step = interval[i] - interval[i-1]
982
969 983 if step > maxstep:
970 984 copyinterval -= 2*numpy.pi
971 985 antialiased[i] = copyinterval[i]
@@ -973,7 +987,7 class FullSpectralAnalysis(Operation):
973 987 elif step < maxstep*(-1):
974 988 copyinterval += 2*numpy.pi
975 989 antialiased[i] = copyinterval[i]
976
990
977 991 else:
978 992 antialiased[i] = copyinterval[i].copy()
979 993
@@ -1003,27 +1017,27 class FullSpectralAnalysis(Operation):
1003 1017 3 : SNR to low or velocity to high -> prec. e.g.
1004 1018 4 : at least one Gaussian of cspc exceeds widthlimit
1005 1019 5 : zero out of three cspc Gaussian fits converged
1006 6 : phase slope fit could not be found
1020 6 : phase slope fit could not be found
1007 1021 7 : arrays used to fit phase have different length
1008 1022 8 : frequency range is either too short (len <= 5) or very long (> 30% of cspc)
1009 1023
1010 1024 """
1011 1025
1012 1026 error_code = 0
1013
1027
1014 1028
1015 1029 SPC_Samples = numpy.ones([spc.shape[0],spc.shape[1]]) # for normalized spc values for one height
1016 1030 phase = numpy.ones([spc.shape[0],spc.shape[1]]) # phase between channels
1017 1031 CSPC_Samples = numpy.ones([spc.shape[0],spc.shape[1]],dtype=numpy.complex_) # for normalized cspc values
1018 1032 PhaseSlope = numpy.zeros(spc.shape[0]) # slope of the phases, channelwise
1019 1033 PhaseInter = numpy.ones(spc.shape[0]) # intercept to the slope of the phases, channelwise
1020 xFrec = AbbsisaRange[0][0:spc.shape[1]] # frequency range
1034 xFrec = AbbsisaRange[0][0:spc.shape[1]] # frequency range
1021 1035 xVel = AbbsisaRange[2][0:spc.shape[1]] # velocity range
1022 1036 SPCav = numpy.average(spc, axis=0)-numpy.average(noise) # spc[0]-noise[0]
1023
1037
1024 1038 SPCmoments_vel = self.Moments(SPCav, xVel ) # SPCmoments_vel[1] corresponds to vertical velocity and is used to determine if signal corresponds to wind (if .. <3)
1025 1039 CSPCmoments = []
1026
1040
1027 1041
1028 1042 '''Getting Eij and Nij'''
1029 1043
@@ -1038,13 +1052,13 class FullSpectralAnalysis(Operation):
1038 1052 spc_norm = spc.copy() # need copy() because untouched spc is needed for normalization of cspc below
1039 1053 spc_norm = numpy.where(numpy.isfinite(spc_norm), spc_norm, numpy.NAN)
1040 1054
1041 for i in range(spc.shape[0]):
1042
1055 for i in range(spc.shape[0]):
1056
1043 1057 spc_sub = spc_norm[i,:] - noise[i] # spc not smoothed here or in previous version.
1044 1058
1045 1059 Factor_Norm = 2*numpy.max(xFrec) / numpy.count_nonzero(~numpy.isnan(spc_sub)) # usually = Freq range / nfft
1046 normalized_spc = spc_sub / (numpy.nansum(numpy.abs(spc_sub)) * Factor_Norm)
1047
1060 normalized_spc = spc_sub / (numpy.nansum(numpy.abs(spc_sub)) * Factor_Norm)
1061
1048 1062 xSamples = xFrec # the frequency range is taken
1049 1063 SPC_Samples[i] = normalized_spc # Normalized SPC values are taken
1050 1064
@@ -1055,49 +1069,49 class FullSpectralAnalysis(Operation):
1055 1069 only for estimation of width. for normalization of cross spectra, you need initial,
1056 1070 unnormalized self-spectra With noise.
1057 1071
1058 Technically, you don't even need to normalize the self-spectra, as you only need the
1072 Technically, you don't even need to normalize the self-spectra, as you only need the
1059 1073 width of the peak. However, it was left this way. Note that the normalization has a flaw:
1060 1074 due to subtraction of the noise, some values are below zero. Raw "spc" values should be
1061 1075 >= 0, as it is the modulus squared of the signals (complex * it's conjugate)
1062 1076 """
1063 1077
1064 SPCMean = numpy.average(SPC_Samples, axis=0)
1065
1078 SPCMean = numpy.average(SPC_Samples, axis=0)
1079
1066 1080 popt = [1e-10,0,1e-10]
1067 1081 SPCMoments = self.Moments(SPCMean, xSamples)
1068 1082
1069 if dbSNR > SNRlimit and numpy.abs(SPCmoments_vel[1]) < 3:
1083 if dbSNR > SNRlimit and numpy.abs(SPCmoments_vel[1]) < 3:
1070 1084 try:
1071 1085 popt,pcov = curve_fit(self.gaus,xSamples,SPCMean,p0=SPCMoments)#, bounds=(-numpy.inf, [numpy.inf, numpy.inf, 10])). Setting bounds does not make the code faster but only keeps the fit from finding the minimum.
1072 1086 if popt[2] > widthlimit: # CONDITION
1073 1087 return self.StopWindEstimation(error_code = 1)
1074 1088
1075 1089 FitGauss = self.gaus(xSamples,*popt)
1076
1090
1077 1091 except :#RuntimeError:
1078 1092 return self.StopWindEstimation(error_code = 2)
1079 1093
1080 1094 else:
1081 1095 return self.StopWindEstimation(error_code = 3)
1082
1096
1083 1097
1084 1098
1085 1099 '''***************************** CSPC Normalization *************************
1086 1100 new section:
1087 1101 The Spc spectra are used to normalize the crossspectra. Peaks from precipitation
1088 influence the norm which is not desired. First, a range is identified where the
1089 wind peak is estimated -> sum_wind is sum of those frequencies. Next, the area
1090 around it gets cut off and values replaced by mean determined by the boundary
1102 influence the norm which is not desired. First, a range is identified where the
1103 wind peak is estimated -> sum_wind is sum of those frequencies. Next, the area
1104 around it gets cut off and values replaced by mean determined by the boundary
1091 1105 data -> sum_noise (spc is not normalized here, thats why the noise is important)
1092 1106
1093 1107 The sums are then added and multiplied by range/datapoints, because you need
1094 1108 an integral and not a sum for normalization.
1095
1096 A norm is found according to Briggs 92.
1109
1110 A norm is found according to Briggs 92.
1097 1111 '''
1098 1112
1099 1113 radarWavelength = 0.6741 # meters
1100 count_limit_freq = numpy.abs(popt[1]) + widthlimit # Hz, m/s can be also used if velocity is desired abscissa.
1114 count_limit_freq = numpy.abs(popt[1]) + widthlimit # Hz, m/s can be also used if velocity is desired abscissa.
1101 1115 # count_limit_freq = numpy.max(xFrec)
1102 1116
1103 1117 channel_integrals = numpy.zeros(3)
@@ -1108,11 +1122,11 class FullSpectralAnalysis(Operation):
1108 1122 sum over all frequencies in the range around zero Hz @ math.ceil(N_freq/2)
1109 1123 '''
1110 1124 N_freq = numpy.count_nonzero(~numpy.isnan(spc[i,:]))
1111 count_limit_int = int(math.ceil( count_limit_freq / numpy.max(xFrec) * (N_freq / 2) )) # gives integer point
1125 count_limit_int = int(math.ceil( count_limit_freq / numpy.max(xFrec) * (N_freq / 2) )) # gives integer point
1112 1126 sum_wind = numpy.nansum( spc[i, (math.ceil(N_freq/2) - count_limit_int) : (math.ceil(N_freq / 2) + count_limit_int)] ) #N_freq/2 is where frequency (velocity) is zero, i.e. middle of spectrum.
1113 1127 sum_noise = (numpy.mean(spc[i, :4]) + numpy.mean(spc[i, -6:-2]))/2.0 * (N_freq - 2*count_limit_int)
1114 1128 channel_integrals[i] = (sum_noise + sum_wind) * (2*numpy.max(xFrec) / N_freq)
1115
1129
1116 1130
1117 1131 cross_integrals_peak = numpy.zeros(3)
1118 1132 # cross_integrals_totalrange = numpy.zeros(3)
@@ -1125,45 +1139,45 class FullSpectralAnalysis(Operation):
1125 1139 chan_index1 = pairsList[i][1]
1126 1140
1127 1141 cross_integrals_peak[i] = channel_integrals[chan_index0]*channel_integrals[chan_index1]
1128 normalized_cspc = cspc_norm / numpy.sqrt(cross_integrals_peak[i])
1142 normalized_cspc = cspc_norm / numpy.sqrt(cross_integrals_peak[i])
1129 1143 CSPC_Samples[i] = normalized_cspc
1130 1144
1131 1145 ''' Finding cross integrals without subtracting any peaks:'''
1132 1146 # FactorNorm0 = 2*numpy.max(xFrec) / numpy.count_nonzero(~numpy.isnan(spc[chan_index0,:]))
1133 1147 # FactorNorm1 = 2*numpy.max(xFrec) / numpy.count_nonzero(~numpy.isnan(spc[chan_index1,:]))
1134 # cross_integrals_totalrange[i] = (numpy.nansum(spc[chan_index0,:])) * FactorNorm0 * (numpy.nansum(spc[chan_index1,:])) * FactorNorm1
1135 # normalized_cspc = cspc_norm / numpy.sqrt(cross_integrals_totalrange[i])
1148 # cross_integrals_totalrange[i] = (numpy.nansum(spc[chan_index0,:])) * FactorNorm0 * (numpy.nansum(spc[chan_index1,:])) * FactorNorm1
1149 # normalized_cspc = cspc_norm / numpy.sqrt(cross_integrals_totalrange[i])
1136 1150 # CSPC_Samples[i] = normalized_cspc
1137
1138
1151
1152
1139 1153 phase[i] = numpy.arctan2(CSPC_Samples[i].imag, CSPC_Samples[i].real)
1140 1154
1141 1155
1142 1156 CSPCmoments = numpy.vstack([self.Moments(numpy.abs(CSPC_Samples[0]), xSamples),
1143 1157 self.Moments(numpy.abs(CSPC_Samples[1]), xSamples),
1144 1158 self.Moments(numpy.abs(CSPC_Samples[2]), xSamples)])
1145
1159
1146 1160
1147 1161 '''***Sorting out NaN entries***'''
1148 1162 CSPCMask01 = numpy.abs(CSPC_Samples[0])
1149 1163 CSPCMask02 = numpy.abs(CSPC_Samples[1])
1150 1164 CSPCMask12 = numpy.abs(CSPC_Samples[2])
1151
1165
1152 1166 mask01 = ~numpy.isnan(CSPCMask01)
1153 1167 mask02 = ~numpy.isnan(CSPCMask02)
1154 1168 mask12 = ~numpy.isnan(CSPCMask12)
1155
1169
1156 1170 CSPCMask01 = CSPCMask01[mask01]
1157 1171 CSPCMask02 = CSPCMask02[mask02]
1158 1172 CSPCMask12 = CSPCMask12[mask12]
1159 1173
1160
1161 popt01, popt02, popt12 = [1e-10,1e-10,1e-10], [1e-10,1e-10,1e-10] ,[1e-10,1e-10,1e-10]
1174
1175 popt01, popt02, popt12 = [1e-10,1e-10,1e-10], [1e-10,1e-10,1e-10] ,[1e-10,1e-10,1e-10]
1162 1176 FitGauss01, FitGauss02, FitGauss12 = numpy.empty(len(xSamples))*0, numpy.empty(len(xSamples))*0, numpy.empty(len(xSamples))*0
1163
1177
1164 1178 '''*******************************FIT GAUSS CSPC************************************'''
1165 1179
1166 try:
1180 try:
1167 1181 popt01,pcov = curve_fit(self.gaus,xSamples[mask01],numpy.abs(CSPCMask01),p0=CSPCmoments[0])
1168 1182 if popt01[2] > widthlimit: # CONDITION
1169 1183 return self.StopWindEstimation(error_code = 4)
@@ -1186,53 +1200,53 class FullSpectralAnalysis(Operation):
1186 1200
1187 1201 '''************* Getting Fij ***************'''
1188 1202
1189
1190 #Punto en Eje X de la Gaussiana donde se encuentra el centro -- x-axis point of the gaussian where the center is located
1191 # -> PointGauCenter
1192 GaussCenter = popt[1]
1203
1204 #Punto en Eje X de la Gaussiana donde se encuentra el centro -- x-axis point of the gaussian where the center is located
1205 # -> PointGauCenter
1206 GaussCenter = popt[1]
1193 1207 ClosestCenter = xSamples[numpy.abs(xSamples-GaussCenter).argmin()]
1194 1208 PointGauCenter = numpy.where(xSamples==ClosestCenter)[0][0]
1195
1209
1196 1210 #Punto e^-1 hubicado en la Gaussiana -- point where e^-1 is located in the gaussian
1197 1211 PeMinus1 = numpy.max(FitGauss) * numpy.exp(-1)
1198 1212 FijClosest = FitGauss[numpy.abs(FitGauss-PeMinus1).argmin()] # El punto mas cercano a "Peminus1" dentro de "FitGauss"
1199 1213 PointFij = numpy.where(FitGauss==FijClosest)[0][0]
1200 1214
1201 1215 Fij = numpy.abs(xSamples[PointFij] - xSamples[PointGauCenter])
1202
1216
1203 1217 '''********** Taking frequency ranges from mean SPCs **********'''
1204
1218
1205 1219 #GaussCenter = popt[1] #Primer momento 01
1206 1220 GauWidth = popt[2] * 3/2 #Ancho de banda de Gau01 -- Bandwidth of Gau01 TODO why *3/2?
1207 1221 Range = numpy.empty(2)
1208 1222 Range[0] = GaussCenter - GauWidth
1209 Range[1] = GaussCenter + GauWidth
1223 Range[1] = GaussCenter + GauWidth
1210 1224 #Punto en Eje X de la Gaussiana donde se encuentra ancho de banda (min:max) -- Point in x-axis where the bandwidth is located (min:max)
1211 1225 ClosRangeMin = xSamples[numpy.abs(xSamples-Range[0]).argmin()]
1212 1226 ClosRangeMax = xSamples[numpy.abs(xSamples-Range[1]).argmin()]
1213
1227
1214 1228 PointRangeMin = numpy.where(xSamples==ClosRangeMin)[0][0]
1215 1229 PointRangeMax = numpy.where(xSamples==ClosRangeMax)[0][0]
1216
1230
1217 1231 Range = numpy.array([ PointRangeMin, PointRangeMax ])
1218
1232
1219 1233 FrecRange = xFrec[ Range[0] : Range[1] ]
1220 1234
1221
1222 '''************************** Getting Phase Slope ***************************'''
1223
1224 for i in range(1,3): # Changed to only compute two
1225
1235
1236 '''************************** Getting Phase Slope ***************************'''
1237
1238 for i in range(1,3): # Changed to only compute two
1239
1226 1240 if len(FrecRange) > 5 and len(FrecRange) < spc.shape[1] * 0.3:
1227 1241 # PhaseRange=self.moving_average(phase[i,Range[0]:Range[1]],N=1) #used before to smooth phase with N=3
1228 1242 PhaseRange = phase[i,Range[0]:Range[1]].copy()
1229
1243
1230 1244 mask = ~numpy.isnan(FrecRange) & ~numpy.isnan(PhaseRange)
1231
1245
1232 1246
1233 1247 if len(FrecRange) == len(PhaseRange):
1234
1235 try:
1248
1249 try:
1236 1250 slope, intercept, _, _, _ = stats.linregress(FrecRange[mask], self.AntiAliasing(PhaseRange[mask], 4.5))
1237 1251 PhaseSlope[i] = slope
1238 1252 PhaseInter[i] = intercept
@@ -1242,49 +1256,49 class FullSpectralAnalysis(Operation):
1242 1256
1243 1257 else:
1244 1258 return self.StopWindEstimation(error_code = 7)
1245
1259
1246 1260 else:
1247 1261 return self.StopWindEstimation(error_code = 8)
1248
1249
1250
1262
1263
1264
1251 1265 '''*** Constants A-H correspond to the convention as in Briggs and Vincent 1992 ***'''
1252 1266
1253 1267 '''Getting constant C'''
1254 1268 cC=(Fij*numpy.pi)**2
1255
1269
1256 1270 '''****** Getting constants F and G ******'''
1257 1271 MijEijNij = numpy.array([[Xi02,Eta02], [Xi12,Eta12]])
1258 1272 MijResult0 = (-PhaseSlope[1] * cC) / (2*numpy.pi)
1259 MijResult1 = (-PhaseSlope[2] * cC) / (2*numpy.pi)
1273 MijResult1 = (-PhaseSlope[2] * cC) / (2*numpy.pi)
1260 1274 MijResults = numpy.array([MijResult0,MijResult1])
1261 (cF,cG) = numpy.linalg.solve(MijEijNij, MijResults)
1262
1275 (cF,cG) = numpy.linalg.solve(MijEijNij, MijResults)
1276
1263 1277 '''****** Getting constants A, B and H ******'''
1264 W01 = numpy.nanmax( FitGauss01 )
1265 W02 = numpy.nanmax( FitGauss02 )
1266 W12 = numpy.nanmax( FitGauss12 )
1267
1278 W01 = numpy.nanmax( FitGauss01 )
1279 W02 = numpy.nanmax( FitGauss02 )
1280 W12 = numpy.nanmax( FitGauss12 )
1281
1268 1282 WijResult0 = ((cF * Xi01 + cG * Eta01)**2)/cC - numpy.log(W01 / numpy.sqrt(numpy.pi / cC))
1269 1283 WijResult1 = ((cF * Xi02 + cG * Eta02)**2)/cC - numpy.log(W02 / numpy.sqrt(numpy.pi / cC))
1270 1284 WijResult2 = ((cF * Xi12 + cG * Eta12)**2)/cC - numpy.log(W12 / numpy.sqrt(numpy.pi / cC))
1271
1285
1272 1286 WijResults = numpy.array([WijResult0, WijResult1, WijResult2])
1273
1274 WijEijNij = numpy.array([ [Xi01**2, Eta01**2, 2*Xi01*Eta01] , [Xi02**2, Eta02**2, 2*Xi02*Eta02] , [Xi12**2, Eta12**2, 2*Xi12*Eta12] ])
1287
1288 WijEijNij = numpy.array([ [Xi01**2, Eta01**2, 2*Xi01*Eta01] , [Xi02**2, Eta02**2, 2*Xi02*Eta02] , [Xi12**2, Eta12**2, 2*Xi12*Eta12] ])
1275 1289 (cA,cB,cH) = numpy.linalg.solve(WijEijNij, WijResults)
1276
1290
1277 1291 VxVy = numpy.array([[cA,cH],[cH,cB]])
1278 1292 VxVyResults = numpy.array([-cF,-cG])
1279 1293 (Vx,Vy) = numpy.linalg.solve(VxVy, VxVyResults)
1280
1294
1281 1295 Vzon = Vy
1282 1296 Vmer = Vx
1283
1297
1284 1298 # Vmag=numpy.sqrt(Vzon**2+Vmer**2) # unused
1285 1299 # Vang=numpy.arctan2(Vmer,Vzon) # unused
1286 1300
1287
1301
1288 1302 ''' using frequency as abscissa. Due to three channels, the offzenith angle is zero
1289 1303 and Vrad equal to Vver. formula taken from Briggs 92, figure 4.
1290 1304 '''
@@ -1295,40 +1309,40 class FullSpectralAnalysis(Operation):
1295 1309
1296 1310 error_code = 0
1297 1311
1298 return Vzon, Vmer, Vver, error_code
1312 return Vzon, Vmer, Vver, error_code
1299 1313
1300 1314
1301 1315 class SpectralMoments(Operation):
1302
1316
1303 1317 '''
1304 1318 Function SpectralMoments()
1305
1319
1306 1320 Calculates moments (power, mean, standard deviation) and SNR of the signal
1307
1321
1308 1322 Type of dataIn: Spectra
1309
1323
1310 1324 Configuration Parameters:
1311
1325
1312 1326 dirCosx : Cosine director in X axis
1313 1327 dirCosy : Cosine director in Y axis
1314
1328
1315 1329 elevation :
1316 1330 azimuth :
1317
1331
1318 1332 Input:
1319 channelList : simple channel list to select e.g. [2,3,7]
1333 channelList : simple channel list to select e.g. [2,3,7]
1320 1334 self.dataOut.data_pre : Spectral data
1321 1335 self.dataOut.abscissaList : List of frequencies
1322 1336 self.dataOut.noise : Noise level per channel
1323
1337
1324 1338 Affected:
1325 1339 self.dataOut.moments : Parameters per channel
1326 1340 self.dataOut.data_SNR : SNR per channel
1327
1341
1328 1342 '''
1329
1343
1330 1344 def run(self, dataOut):
1331
1345
1332 1346 data = dataOut.data_pre[0]
1333 1347 absc = dataOut.abscissaList[:-1]
1334 1348 noise = dataOut.noise
@@ -1337,7 +1351,7 class SpectralMoments(Operation):
1337 1351
1338 1352 for ind in range(nChannel):
1339 1353 data_param[ind,:,:] = self.__calculateMoments( data[ind,:,:] , absc , noise[ind] )
1340
1354
1341 1355 dataOut.moments = data_param[:,1:,:]
1342 1356 dataOut.data_SNR = data_param[:,0]
1343 1357 dataOut.data_POW = data_param[:,1]
@@ -1345,12 +1359,12 class SpectralMoments(Operation):
1345 1359 dataOut.data_WIDTH = data_param[:,3]
1346 1360
1347 1361 return dataOut
1348
1349 def __calculateMoments(self, oldspec, oldfreq, n0,
1362
1363 def __calculateMoments(self, oldspec, oldfreq, n0,
1350 1364 nicoh = None, graph = None, smooth = None, type1 = None, fwindow = None, snrth = None, dc = None, aliasing = None, oldfd = None, wwauto = None):
1351
1365
1352 1366 if (nicoh is None): nicoh = 1
1353 if (graph is None): graph = 0
1367 if (graph is None): graph = 0
1354 1368 if (smooth is None): smooth = 0
1355 1369 elif (self.smooth < 3): smooth = 0
1356 1370
@@ -1361,102 +1375,102 class SpectralMoments(Operation):
1361 1375 if (aliasing is None): aliasing = 0
1362 1376 if (oldfd is None): oldfd = 0
1363 1377 if (wwauto is None): wwauto = 0
1364
1378
1365 1379 if (n0 < 1.e-20): n0 = 1.e-20
1366
1380
1367 1381 freq = oldfreq
1368 1382 vec_power = numpy.zeros(oldspec.shape[1])
1369 1383 vec_fd = numpy.zeros(oldspec.shape[1])
1370 1384 vec_w = numpy.zeros(oldspec.shape[1])
1371 1385 vec_snr = numpy.zeros(oldspec.shape[1])
1372
1386
1373 1387 # oldspec = numpy.ma.masked_invalid(oldspec)
1374
1388
1375 1389 for ind in range(oldspec.shape[1]):
1376
1390
1377 1391 spec = oldspec[:,ind]
1378 1392 aux = spec*fwindow
1379 1393 max_spec = aux.max()
1380 1394 m = aux.tolist().index(max_spec)
1381
1382 #Smooth
1395
1396 #Smooth
1383 1397 if (smooth == 0):
1384 1398 spec2 = spec
1385 1399 else:
1386 1400 spec2 = scipy.ndimage.filters.uniform_filter1d(spec,size=smooth)
1387
1401
1388 1402 # Calculo de Momentos
1389 1403 bb = spec2[numpy.arange(m,spec2.size)]
1390 1404 bb = (bb<n0).nonzero()
1391 1405 bb = bb[0]
1392
1406
1393 1407 ss = spec2[numpy.arange(0,m + 1)]
1394 1408 ss = (ss<n0).nonzero()
1395 1409 ss = ss[0]
1396
1410
1397 1411 if (bb.size == 0):
1398 1412 bb0 = spec.size - 1 - m
1399 else:
1413 else:
1400 1414 bb0 = bb[0] - 1
1401 1415 if (bb0 < 0):
1402 1416 bb0 = 0
1403
1417
1404 1418 if (ss.size == 0):
1405 1419 ss1 = 1
1406 1420 else:
1407 1421 ss1 = max(ss) + 1
1408
1422
1409 1423 if (ss1 > m):
1410 1424 ss1 = m
1411
1412 valid = numpy.arange(int(m + bb0 - ss1 + 1)) + ss1
1413
1425
1426 valid = numpy.arange(int(m + bb0 - ss1 + 1)) + ss1
1427
1414 1428 power = ((spec2[valid] - n0) * fwindow[valid]).sum()
1415 1429 fd = ((spec2[valid]- n0)*freq[valid] * fwindow[valid]).sum() / power
1416 1430 w = numpy.sqrt(((spec2[valid] - n0)*fwindow[valid]*(freq[valid]- fd)**2).sum() / power)
1417 1431 snr = (spec2.mean()-n0)/n0
1418 if (snr < 1.e-20) :
1432 if (snr < 1.e-20) :
1419 1433 snr = 1.e-20
1420
1434
1421 1435 vec_power[ind] = power
1422 1436 vec_fd[ind] = fd
1423 1437 vec_w[ind] = w
1424 1438 vec_snr[ind] = snr
1425 1439
1426 1440 return numpy.vstack((vec_snr, vec_power, vec_fd, vec_w))
1427
1441
1428 1442 #------------------ Get SA Parameters --------------------------
1429
1443
1430 1444 def GetSAParameters(self):
1431 1445 #SA en frecuencia
1432 1446 pairslist = self.dataOut.groupList
1433 1447 num_pairs = len(pairslist)
1434
1448
1435 1449 vel = self.dataOut.abscissaList
1436 1450 spectra = self.dataOut.data_pre
1437 1451 cspectra = self.dataIn.data_cspc
1438 delta_v = vel[1] - vel[0]
1439
1452 delta_v = vel[1] - vel[0]
1453
1440 1454 #Calculating the power spectrum
1441 1455 spc_pow = numpy.sum(spectra, 3)*delta_v
1442 1456 #Normalizing Spectra
1443 1457 norm_spectra = spectra/spc_pow
1444 1458 #Calculating the norm_spectra at peak
1445 max_spectra = numpy.max(norm_spectra, 3)
1446
1459 max_spectra = numpy.max(norm_spectra, 3)
1460
1447 1461 #Normalizing Cross Spectra
1448 1462 norm_cspectra = numpy.zeros(cspectra.shape)
1449
1463
1450 1464 for i in range(num_chan):
1451 1465 norm_cspectra[i,:,:] = cspectra[i,:,:]/numpy.sqrt(spc_pow[pairslist[i][0],:]*spc_pow[pairslist[i][1],:])
1452
1466
1453 1467 max_cspectra = numpy.max(norm_cspectra,2)
1454 1468 max_cspectra_index = numpy.argmax(norm_cspectra, 2)
1455
1469
1456 1470 for i in range(num_pairs):
1457 1471 cspc_par[i,:,:] = __calculateMoments(norm_cspectra)
1458 1472 #------------------- Get Lags ----------------------------------
1459
1473
1460 1474 class SALags(Operation):
1461 1475 '''
1462 1476 Function GetMoments()
@@ -1469,19 +1483,19 class SALags(Operation):
1469 1483 self.dataOut.data_SNR
1470 1484 self.dataOut.groupList
1471 1485 self.dataOut.nChannels
1472
1486
1473 1487 Affected:
1474 1488 self.dataOut.data_param
1475
1489
1476 1490 '''
1477 def run(self, dataOut):
1491 def run(self, dataOut):
1478 1492 data_acf = dataOut.data_pre[0]
1479 1493 data_ccf = dataOut.data_pre[1]
1480 1494 normFactor_acf = dataOut.normFactor[0]
1481 1495 normFactor_ccf = dataOut.normFactor[1]
1482 1496 pairs_acf = dataOut.groupList[0]
1483 1497 pairs_ccf = dataOut.groupList[1]
1484
1498
1485 1499 nHeights = dataOut.nHeights
1486 1500 absc = dataOut.abscissaList
1487 1501 noise = dataOut.noise
@@ -1492,97 +1506,97 class SALags(Operation):
1492 1506
1493 1507 for l in range(len(pairs_acf)):
1494 1508 data_acf[l,:,:] = data_acf[l,:,:]/normFactor_acf[l,:]
1495
1509
1496 1510 for l in range(len(pairs_ccf)):
1497 1511 data_ccf[l,:,:] = data_ccf[l,:,:]/normFactor_ccf[l,:]
1498
1512
1499 1513 dataOut.data_param = numpy.zeros((len(pairs_ccf)*2 + 1, nHeights))
1500 1514 dataOut.data_param[:-1,:] = self.__calculateTaus(data_acf, data_ccf, absc)
1501 1515 dataOut.data_param[-1,:] = self.__calculateLag1Phase(data_acf, absc)
1502 1516 return
1503
1517
1504 1518 # def __getPairsAutoCorr(self, pairsList, nChannels):
1505 #
1519 #
1506 1520 # pairsAutoCorr = numpy.zeros(nChannels, dtype = 'int')*numpy.nan
1507 #
1508 # for l in range(len(pairsList)):
1521 #
1522 # for l in range(len(pairsList)):
1509 1523 # firstChannel = pairsList[l][0]
1510 1524 # secondChannel = pairsList[l][1]
1511 #
1512 # #Obteniendo pares de Autocorrelacion
1525 #
1526 # #Obteniendo pares de Autocorrelacion
1513 1527 # if firstChannel == secondChannel:
1514 1528 # pairsAutoCorr[firstChannel] = int(l)
1515 #
1529 #
1516 1530 # pairsAutoCorr = pairsAutoCorr.astype(int)
1517 #
1531 #
1518 1532 # pairsCrossCorr = range(len(pairsList))
1519 1533 # pairsCrossCorr = numpy.delete(pairsCrossCorr,pairsAutoCorr)
1520 #
1534 #
1521 1535 # return pairsAutoCorr, pairsCrossCorr
1522
1536
1523 1537 def __calculateTaus(self, data_acf, data_ccf, lagRange):
1524
1538
1525 1539 lag0 = data_acf.shape[1]/2
1526 1540 #Funcion de Autocorrelacion
1527 1541 mean_acf = stats.nanmean(data_acf, axis = 0)
1528
1542
1529 1543 #Obtencion Indice de TauCross
1530 1544 ind_ccf = data_ccf.argmax(axis = 1)
1531 1545 #Obtencion Indice de TauAuto
1532 1546 ind_acf = numpy.zeros(ind_ccf.shape,dtype = 'int')
1533 1547 ccf_lag0 = data_ccf[:,lag0,:]
1534
1548
1535 1549 for i in range(ccf_lag0.shape[0]):
1536 1550 ind_acf[i,:] = numpy.abs(mean_acf - ccf_lag0[i,:]).argmin(axis = 0)
1537
1551
1538 1552 #Obtencion de TauCross y TauAuto
1539 1553 tau_ccf = lagRange[ind_ccf]
1540 1554 tau_acf = lagRange[ind_acf]
1541
1555
1542 1556 Nan1, Nan2 = numpy.where(tau_ccf == lagRange[0])
1543
1557
1544 1558 tau_ccf[Nan1,Nan2] = numpy.nan
1545 1559 tau_acf[Nan1,Nan2] = numpy.nan
1546 1560 tau = numpy.vstack((tau_ccf,tau_acf))
1547
1561
1548 1562 return tau
1549
1563
1550 1564 def __calculateLag1Phase(self, data, lagTRange):
1551 1565 data1 = stats.nanmean(data, axis = 0)
1552 1566 lag1 = numpy.where(lagTRange == 0)[0][0] + 1
1553 1567
1554 1568 phase = numpy.angle(data1[lag1,:])
1555
1569
1556 1570 return phase
1557
1571
1558 1572 class SpectralFitting(Operation):
1559 1573 '''
1560 1574 Function GetMoments()
1561
1575
1562 1576 Input:
1563 1577 Output:
1564 1578 Variables modified:
1565 1579 '''
1566
1567 def run(self, dataOut, getSNR = True, path=None, file=None, groupList=None):
1568
1569
1580
1581 def run(self, dataOut, getSNR = True, path=None, file=None, groupList=None):
1582
1583
1570 1584 if path != None:
1571 1585 sys.path.append(path)
1572 1586 self.dataOut.library = importlib.import_module(file)
1573
1587
1574 1588 #To be inserted as a parameter
1575 1589 groupArray = numpy.array(groupList)
1576 # groupArray = numpy.array([[0,1],[2,3]])
1590 # groupArray = numpy.array([[0,1],[2,3]])
1577 1591 self.dataOut.groupList = groupArray
1578
1592
1579 1593 nGroups = groupArray.shape[0]
1580 1594 nChannels = self.dataIn.nChannels
1581 1595 nHeights=self.dataIn.heightList.size
1582
1596
1583 1597 #Parameters Array
1584 1598 self.dataOut.data_param = None
1585
1599
1586 1600 #Set constants
1587 1601 constants = self.dataOut.library.setConstants(self.dataIn)
1588 1602 self.dataOut.constants = constants
@@ -1591,24 +1605,24 class SpectralFitting(Operation):
1591 1605 ippSeconds = self.dataIn.ippSeconds
1592 1606 K = self.dataIn.nIncohInt
1593 1607 pairsArray = numpy.array(self.dataIn.pairsList)
1594
1608
1595 1609 #List of possible combinations
1596 1610 listComb = itertools.combinations(numpy.arange(groupArray.shape[1]),2)
1597 1611 indCross = numpy.zeros(len(list(listComb)), dtype = 'int')
1598
1612
1599 1613 if getSNR:
1600 1614 listChannels = groupArray.reshape((groupArray.size))
1601 1615 listChannels.sort()
1602 1616 noise = self.dataIn.getNoise()
1603 1617 self.dataOut.data_SNR = self.__getSNR(self.dataIn.data_spc[listChannels,:,:], noise[listChannels])
1604
1605 for i in range(nGroups):
1618
1619 for i in range(nGroups):
1606 1620 coord = groupArray[i,:]
1607
1621
1608 1622 #Input data array
1609 1623 data = self.dataIn.data_spc[coord,:,:]/(M*N)
1610 1624 data = data.reshape((data.shape[0]*data.shape[1],data.shape[2]))
1611
1625
1612 1626 #Cross Spectra data array for Covariance Matrixes
1613 1627 ind = 0
1614 1628 for pairs in listComb:
@@ -1617,9 +1631,9 class SpectralFitting(Operation):
1617 1631 ind += 1
1618 1632 dataCross = self.dataIn.data_cspc[indCross,:,:]/(M*N)
1619 1633 dataCross = dataCross**2/K
1620
1634
1621 1635 for h in range(nHeights):
1622
1636
1623 1637 #Input
1624 1638 d = data[:,h]
1625 1639
@@ -1628,7 +1642,7 class SpectralFitting(Operation):
1628 1642 ind = 0
1629 1643 for pairs in listComb:
1630 1644 #Coordinates in Covariance Matrix
1631 x = pairs[0]
1645 x = pairs[0]
1632 1646 y = pairs[1]
1633 1647 #Channel Index
1634 1648 S12 = dataCross[ind,:,h]
@@ -1642,15 +1656,15 class SpectralFitting(Operation):
1642 1656 LT=L.T
1643 1657
1644 1658 dp = numpy.dot(LT,d)
1645
1659
1646 1660 #Initial values
1647 1661 data_spc = self.dataIn.data_spc[coord,:,h]
1648
1662
1649 1663 if (h>0)and(error1[3]<5):
1650 1664 p0 = self.dataOut.data_param[i,:,h-1]
1651 1665 else:
1652 1666 p0 = numpy.array(self.dataOut.library.initialValuesFunction(data_spc, constants, i))
1653
1667
1654 1668 try:
1655 1669 #Least Squares
1656 1670 minp,covp,infodict,mesg,ier = optimize.leastsq(self.__residFunction,p0,args=(dp,LT,constants),full_output=True)
@@ -1663,30 +1677,30 class SpectralFitting(Operation):
1663 1677 minp = p0*numpy.nan
1664 1678 error0 = numpy.nan
1665 1679 error1 = p0*numpy.nan
1666
1680
1667 1681 #Save
1668 1682 if self.dataOut.data_param is None:
1669 1683 self.dataOut.data_param = numpy.zeros((nGroups, p0.size, nHeights))*numpy.nan
1670 1684 self.dataOut.data_error = numpy.zeros((nGroups, p0.size + 1, nHeights))*numpy.nan
1671
1685
1672 1686 self.dataOut.data_error[i,:,h] = numpy.hstack((error0,error1))
1673 1687 self.dataOut.data_param[i,:,h] = minp
1674 1688 return
1675
1689
1676 1690 def __residFunction(self, p, dp, LT, constants):
1677 1691
1678 1692 fm = self.dataOut.library.modelFunction(p, constants)
1679 1693 fmp=numpy.dot(LT,fm)
1680
1694
1681 1695 return dp-fmp
1682 1696
1683 1697 def __getSNR(self, z, noise):
1684
1698
1685 1699 avg = numpy.average(z, axis=1)
1686 1700 SNR = (avg.T-noise)/noise
1687 1701 SNR = SNR.T
1688 1702 return SNR
1689
1703
1690 1704 def __chisq(p,chindex,hindex):
1691 1705 #similar to Resid but calculates CHI**2
1692 1706 [LT,d,fm]=setupLTdfm(p,chindex,hindex)
@@ -1694,53 +1708,53 class SpectralFitting(Operation):
1694 1708 fmp=numpy.dot(LT,fm)
1695 1709 chisq=numpy.dot((dp-fmp).T,(dp-fmp))
1696 1710 return chisq
1697
1711
1698 1712 class WindProfiler(Operation):
1699
1713
1700 1714 __isConfig = False
1701
1715
1702 1716 __initime = None
1703 1717 __lastdatatime = None
1704 1718 __integrationtime = None
1705
1719
1706 1720 __buffer = None
1707
1721
1708 1722 __dataReady = False
1709
1723
1710 1724 __firstdata = None
1711
1725
1712 1726 n = None
1713
1714 def __init__(self):
1727
1728 def __init__(self):
1715 1729 Operation.__init__(self)
1716
1730
1717 1731 def __calculateCosDir(self, elev, azim):
1718 1732 zen = (90 - elev)*numpy.pi/180
1719 1733 azim = azim*numpy.pi/180
1720 cosDirX = numpy.sqrt((1-numpy.cos(zen)**2)/((1+numpy.tan(azim)**2)))
1734 cosDirX = numpy.sqrt((1-numpy.cos(zen)**2)/((1+numpy.tan(azim)**2)))
1721 1735 cosDirY = numpy.sqrt(1-numpy.cos(zen)**2-cosDirX**2)
1722
1736
1723 1737 signX = numpy.sign(numpy.cos(azim))
1724 1738 signY = numpy.sign(numpy.sin(azim))
1725
1739
1726 1740 cosDirX = numpy.copysign(cosDirX, signX)
1727 1741 cosDirY = numpy.copysign(cosDirY, signY)
1728 1742 return cosDirX, cosDirY
1729
1743
1730 1744 def __calculateAngles(self, theta_x, theta_y, azimuth):
1731
1745
1732 1746 dir_cosw = numpy.sqrt(1-theta_x**2-theta_y**2)
1733 1747 zenith_arr = numpy.arccos(dir_cosw)
1734 1748 azimuth_arr = numpy.arctan2(theta_x,theta_y) + azimuth*math.pi/180
1735
1749
1736 1750 dir_cosu = numpy.sin(azimuth_arr)*numpy.sin(zenith_arr)
1737 1751 dir_cosv = numpy.cos(azimuth_arr)*numpy.sin(zenith_arr)
1738
1752
1739 1753 return azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw
1740 1754
1741 1755 def __calculateMatA(self, dir_cosu, dir_cosv, dir_cosw, horOnly):
1742
1743 #
1756
1757 #
1744 1758 if horOnly:
1745 1759 A = numpy.c_[dir_cosu,dir_cosv]
1746 1760 else:
@@ -1754,37 +1768,37 class WindProfiler(Operation):
1754 1768 listPhi = phi.tolist()
1755 1769 maxid = listPhi.index(max(listPhi))
1756 1770 minid = listPhi.index(min(listPhi))
1757
1758 rango = list(range(len(phi)))
1771
1772 rango = list(range(len(phi)))
1759 1773 # rango = numpy.delete(rango,maxid)
1760
1774
1761 1775 heiRang1 = heiRang*math.cos(phi[maxid])
1762 1776 heiRangAux = heiRang*math.cos(phi[minid])
1763 1777 indOut = (heiRang1 < heiRangAux[0]).nonzero()
1764 1778 heiRang1 = numpy.delete(heiRang1,indOut)
1765
1779
1766 1780 velRadial1 = numpy.zeros([len(phi),len(heiRang1)])
1767 1781 SNR1 = numpy.zeros([len(phi),len(heiRang1)])
1768
1782
1769 1783 for i in rango:
1770 1784 x = heiRang*math.cos(phi[i])
1771 1785 y1 = velRadial[i,:]
1772 1786 f1 = interpolate.interp1d(x,y1,kind = 'cubic')
1773
1787
1774 1788 x1 = heiRang1
1775 1789 y11 = f1(x1)
1776
1790
1777 1791 y2 = SNR[i,:]
1778 1792 f2 = interpolate.interp1d(x,y2,kind = 'cubic')
1779 1793 y21 = f2(x1)
1780
1794
1781 1795 velRadial1[i,:] = y11
1782 1796 SNR1[i,:] = y21
1783
1797
1784 1798 return heiRang1, velRadial1, SNR1
1785 1799
1786 1800 def __calculateVelUVW(self, A, velRadial):
1787
1801
1788 1802 #Operacion Matricial
1789 1803 # velUVW = numpy.zeros((velRadial.shape[1],3))
1790 1804 # for ind in range(velRadial.shape[1]):
@@ -1792,27 +1806,27 class WindProfiler(Operation):
1792 1806 # velUVW = velUVW.transpose()
1793 1807 velUVW = numpy.zeros((A.shape[0],velRadial.shape[1]))
1794 1808 velUVW[:,:] = numpy.dot(A,velRadial)
1795
1796
1809
1810
1797 1811 return velUVW
1798
1812
1799 1813 # def techniqueDBS(self, velRadial0, dirCosx, disrCosy, azimuth, correct, horizontalOnly, heiRang, SNR0):
1800
1814
1801 1815 def techniqueDBS(self, kwargs):
1802 1816 """
1803 1817 Function that implements Doppler Beam Swinging (DBS) technique.
1804
1818
1805 1819 Input: Radial velocities, Direction cosines (x and y) of the Beam, Antenna azimuth,
1806 1820 Direction correction (if necessary), Ranges and SNR
1807
1821
1808 1822 Output: Winds estimation (Zonal, Meridional and Vertical)
1809
1823
1810 1824 Parameters affected: Winds, height range, SNR
1811 1825 """
1812 1826 velRadial0 = kwargs['velRadial']
1813 1827 heiRang = kwargs['heightList']
1814 1828 SNR0 = kwargs['SNR']
1815
1829
1816 1830 if 'dirCosx' in kwargs and 'dirCosy' in kwargs:
1817 1831 theta_x = numpy.array(kwargs['dirCosx'])
1818 1832 theta_y = numpy.array(kwargs['dirCosy'])
@@ -1820,7 +1834,7 class WindProfiler(Operation):
1820 1834 elev = numpy.array(kwargs['elevation'])
1821 1835 azim = numpy.array(kwargs['azimuth'])
1822 1836 theta_x, theta_y = self.__calculateCosDir(elev, azim)
1823 azimuth = kwargs['correctAzimuth']
1837 azimuth = kwargs['correctAzimuth']
1824 1838 if 'horizontalOnly' in kwargs:
1825 1839 horizontalOnly = kwargs['horizontalOnly']
1826 1840 else: horizontalOnly = False
@@ -1835,22 +1849,22 class WindProfiler(Operation):
1835 1849 param = param[arrayChannel,:,:]
1836 1850 theta_x = theta_x[arrayChannel]
1837 1851 theta_y = theta_y[arrayChannel]
1838
1839 azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw = self.__calculateAngles(theta_x, theta_y, azimuth)
1840 heiRang1, velRadial1, SNR1 = self.__correctValues(heiRang, zenith_arr, correctFactor*velRadial0, SNR0)
1852
1853 azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw = self.__calculateAngles(theta_x, theta_y, azimuth)
1854 heiRang1, velRadial1, SNR1 = self.__correctValues(heiRang, zenith_arr, correctFactor*velRadial0, SNR0)
1841 1855 A = self.__calculateMatA(dir_cosu, dir_cosv, dir_cosw, horizontalOnly)
1842
1856
1843 1857 #Calculo de Componentes de la velocidad con DBS
1844 1858 winds = self.__calculateVelUVW(A,velRadial1)
1845
1859
1846 1860 return winds, heiRang1, SNR1
1847
1861
1848 1862 def __calculateDistance(self, posx, posy, pairs_ccf, azimuth = None):
1849
1863
1850 1864 nPairs = len(pairs_ccf)
1851 1865 posx = numpy.asarray(posx)
1852 1866 posy = numpy.asarray(posy)
1853
1867
1854 1868 #Rotacion Inversa para alinear con el azimuth
1855 1869 if azimuth!= None:
1856 1870 azimuth = azimuth*math.pi/180
@@ -1859,126 +1873,126 class WindProfiler(Operation):
1859 1873 else:
1860 1874 posx1 = posx
1861 1875 posy1 = posy
1862
1876
1863 1877 #Calculo de Distancias
1864 1878 distx = numpy.zeros(nPairs)
1865 1879 disty = numpy.zeros(nPairs)
1866 1880 dist = numpy.zeros(nPairs)
1867 1881 ang = numpy.zeros(nPairs)
1868
1882
1869 1883 for i in range(nPairs):
1870 1884 distx[i] = posx1[pairs_ccf[i][1]] - posx1[pairs_ccf[i][0]]
1871 disty[i] = posy1[pairs_ccf[i][1]] - posy1[pairs_ccf[i][0]]
1885 disty[i] = posy1[pairs_ccf[i][1]] - posy1[pairs_ccf[i][0]]
1872 1886 dist[i] = numpy.sqrt(distx[i]**2 + disty[i]**2)
1873 1887 ang[i] = numpy.arctan2(disty[i],distx[i])
1874
1888
1875 1889 return distx, disty, dist, ang
1876 #Calculo de Matrices
1890 #Calculo de Matrices
1877 1891 # nPairs = len(pairs)
1878 1892 # ang1 = numpy.zeros((nPairs, 2, 1))
1879 1893 # dist1 = numpy.zeros((nPairs, 2, 1))
1880 #
1894 #
1881 1895 # for j in range(nPairs):
1882 1896 # dist1[j,0,0] = dist[pairs[j][0]]
1883 1897 # dist1[j,1,0] = dist[pairs[j][1]]
1884 1898 # ang1[j,0,0] = ang[pairs[j][0]]
1885 1899 # ang1[j,1,0] = ang[pairs[j][1]]
1886 #
1900 #
1887 1901 # return distx,disty, dist1,ang1
1888 1902
1889
1903
1890 1904 def __calculateVelVer(self, phase, lagTRange, _lambda):
1891 1905
1892 1906 Ts = lagTRange[1] - lagTRange[0]
1893 1907 velW = -_lambda*phase/(4*math.pi*Ts)
1894
1908
1895 1909 return velW
1896
1910
1897 1911 def __calculateVelHorDir(self, dist, tau1, tau2, ang):
1898 1912 nPairs = tau1.shape[0]
1899 1913 nHeights = tau1.shape[1]
1900 vel = numpy.zeros((nPairs,3,nHeights))
1914 vel = numpy.zeros((nPairs,3,nHeights))
1901 1915 dist1 = numpy.reshape(dist, (dist.size,1))
1902
1916
1903 1917 angCos = numpy.cos(ang)
1904 1918 angSin = numpy.sin(ang)
1905
1906 vel0 = dist1*tau1/(2*tau2**2)
1919
1920 vel0 = dist1*tau1/(2*tau2**2)
1907 1921 vel[:,0,:] = (vel0*angCos).sum(axis = 1)
1908 1922 vel[:,1,:] = (vel0*angSin).sum(axis = 1)
1909
1923
1910 1924 ind = numpy.where(numpy.isinf(vel))
1911 1925 vel[ind] = numpy.nan
1912
1926
1913 1927 return vel
1914
1928
1915 1929 # def __getPairsAutoCorr(self, pairsList, nChannels):
1916 #
1930 #
1917 1931 # pairsAutoCorr = numpy.zeros(nChannels, dtype = 'int')*numpy.nan
1918 #
1919 # for l in range(len(pairsList)):
1932 #
1933 # for l in range(len(pairsList)):
1920 1934 # firstChannel = pairsList[l][0]
1921 1935 # secondChannel = pairsList[l][1]
1922 #
1923 # #Obteniendo pares de Autocorrelacion
1936 #
1937 # #Obteniendo pares de Autocorrelacion
1924 1938 # if firstChannel == secondChannel:
1925 1939 # pairsAutoCorr[firstChannel] = int(l)
1926 #
1940 #
1927 1941 # pairsAutoCorr = pairsAutoCorr.astype(int)
1928 #
1942 #
1929 1943 # pairsCrossCorr = range(len(pairsList))
1930 1944 # pairsCrossCorr = numpy.delete(pairsCrossCorr,pairsAutoCorr)
1931 #
1945 #
1932 1946 # return pairsAutoCorr, pairsCrossCorr
1933
1947
1934 1948 # def techniqueSA(self, pairsSelected, pairsList, nChannels, tau, azimuth, _lambda, position_x, position_y, lagTRange, correctFactor):
1935 1949 def techniqueSA(self, kwargs):
1936
1937 """
1950
1951 """
1938 1952 Function that implements Spaced Antenna (SA) technique.
1939
1953
1940 1954 Input: Radial velocities, Direction cosines (x and y) of the Beam, Antenna azimuth,
1941 1955 Direction correction (if necessary), Ranges and SNR
1942
1956
1943 1957 Output: Winds estimation (Zonal, Meridional and Vertical)
1944
1958
1945 1959 Parameters affected: Winds
1946 1960 """
1947 1961 position_x = kwargs['positionX']
1948 1962 position_y = kwargs['positionY']
1949 1963 azimuth = kwargs['azimuth']
1950
1964
1951 1965 if 'correctFactor' in kwargs:
1952 1966 correctFactor = kwargs['correctFactor']
1953 1967 else:
1954 1968 correctFactor = 1
1955
1969
1956 1970 groupList = kwargs['groupList']
1957 1971 pairs_ccf = groupList[1]
1958 1972 tau = kwargs['tau']
1959 1973 _lambda = kwargs['_lambda']
1960
1974
1961 1975 #Cross Correlation pairs obtained
1962 1976 # pairsAutoCorr, pairsCrossCorr = self.__getPairsAutoCorr(pairssList, nChannels)
1963 1977 # pairsArray = numpy.array(pairsList)[pairsCrossCorr]
1964 1978 # pairsSelArray = numpy.array(pairsSelected)
1965 1979 # pairs = []
1966 #
1980 #
1967 1981 # #Wind estimation pairs obtained
1968 1982 # for i in range(pairsSelArray.shape[0]/2):
1969 1983 # ind1 = numpy.where(numpy.all(pairsArray == pairsSelArray[2*i], axis = 1))[0][0]
1970 1984 # ind2 = numpy.where(numpy.all(pairsArray == pairsSelArray[2*i + 1], axis = 1))[0][0]
1971 1985 # pairs.append((ind1,ind2))
1972
1986
1973 1987 indtau = tau.shape[0]/2
1974 1988 tau1 = tau[:indtau,:]
1975 1989 tau2 = tau[indtau:-1,:]
1976 1990 # tau1 = tau1[pairs,:]
1977 1991 # tau2 = tau2[pairs,:]
1978 1992 phase1 = tau[-1,:]
1979
1993
1980 1994 #---------------------------------------------------------------------
1981 #Metodo Directo
1995 #Metodo Directo
1982 1996 distx, disty, dist, ang = self.__calculateDistance(position_x, position_y, pairs_ccf,azimuth)
1983 1997 winds = self.__calculateVelHorDir(dist, tau1, tau2, ang)
1984 1998 winds = stats.nanmean(winds, axis=0)
@@ -1994,97 +2008,97 class WindProfiler(Operation):
1994 2008 winds[2,:] = self.__calculateVelVer(phase1, lagTRange, _lambda)
1995 2009 winds = correctFactor*winds
1996 2010 return winds
1997
2011
1998 2012 def __checkTime(self, currentTime, paramInterval, outputInterval):
1999
2013
2000 2014 dataTime = currentTime + paramInterval
2001 2015 deltaTime = dataTime - self.__initime
2002
2016
2003 2017 if deltaTime >= outputInterval or deltaTime < 0:
2004 2018 self.__dataReady = True
2005 return
2006
2019 return
2020
2007 2021 def techniqueMeteors(self, arrayMeteor, meteorThresh, heightMin, heightMax):
2008 2022 '''
2009 2023 Function that implements winds estimation technique with detected meteors.
2010
2024
2011 2025 Input: Detected meteors, Minimum meteor quantity to wind estimation
2012
2026
2013 2027 Output: Winds estimation (Zonal and Meridional)
2014
2028
2015 2029 Parameters affected: Winds
2016 '''
2030 '''
2017 2031 #Settings
2018 2032 nInt = (heightMax - heightMin)/2
2019 2033 nInt = int(nInt)
2020 winds = numpy.zeros((2,nInt))*numpy.nan
2021
2034 winds = numpy.zeros((2,nInt))*numpy.nan
2035
2022 2036 #Filter errors
2023 2037 error = numpy.where(arrayMeteor[:,-1] == 0)[0]
2024 2038 finalMeteor = arrayMeteor[error,:]
2025
2039
2026 2040 #Meteor Histogram
2027 2041 finalHeights = finalMeteor[:,2]
2028 2042 hist = numpy.histogram(finalHeights, bins = nInt, range = (heightMin,heightMax))
2029 2043 nMeteorsPerI = hist[0]
2030 2044 heightPerI = hist[1]
2031
2045
2032 2046 #Sort of meteors
2033 2047 indSort = finalHeights.argsort()
2034 2048 finalMeteor2 = finalMeteor[indSort,:]
2035
2049
2036 2050 # Calculating winds
2037 2051 ind1 = 0
2038 ind2 = 0
2039
2052 ind2 = 0
2053
2040 2054 for i in range(nInt):
2041 2055 nMet = nMeteorsPerI[i]
2042 2056 ind1 = ind2
2043 2057 ind2 = ind1 + nMet
2044
2058
2045 2059 meteorAux = finalMeteor2[ind1:ind2,:]
2046
2060
2047 2061 if meteorAux.shape[0] >= meteorThresh:
2048 2062 vel = meteorAux[:, 6]
2049 2063 zen = meteorAux[:, 4]*numpy.pi/180
2050 2064 azim = meteorAux[:, 3]*numpy.pi/180
2051
2065
2052 2066 n = numpy.cos(zen)
2053 2067 # m = (1 - n**2)/(1 - numpy.tan(azim)**2)
2054 2068 # l = m*numpy.tan(azim)
2055 2069 l = numpy.sin(zen)*numpy.sin(azim)
2056 2070 m = numpy.sin(zen)*numpy.cos(azim)
2057
2071
2058 2072 A = numpy.vstack((l, m)).transpose()
2059 2073 A1 = numpy.dot(numpy.linalg.inv( numpy.dot(A.transpose(),A) ),A.transpose())
2060 2074 windsAux = numpy.dot(A1, vel)
2061
2075
2062 2076 winds[0,i] = windsAux[0]
2063 2077 winds[1,i] = windsAux[1]
2064
2078
2065 2079 return winds, heightPerI[:-1]
2066
2080
2067 2081 def techniqueNSM_SA(self, **kwargs):
2068 2082 metArray = kwargs['metArray']
2069 2083 heightList = kwargs['heightList']
2070 2084 timeList = kwargs['timeList']
2071
2085
2072 2086 rx_location = kwargs['rx_location']
2073 2087 groupList = kwargs['groupList']
2074 2088 azimuth = kwargs['azimuth']
2075 2089 dfactor = kwargs['dfactor']
2076 2090 k = kwargs['k']
2077
2091
2078 2092 azimuth1, dist = self.__calculateAzimuth1(rx_location, groupList, azimuth)
2079 2093 d = dist*dfactor
2080 2094 #Phase calculation
2081 2095 metArray1 = self.__getPhaseSlope(metArray, heightList, timeList)
2082
2096
2083 2097 metArray1[:,-2] = metArray1[:,-2]*metArray1[:,2]*1000/(k*d[metArray1[:,1].astype(int)]) #angles into velocities
2084
2098
2085 2099 velEst = numpy.zeros((heightList.size,2))*numpy.nan
2086 2100 azimuth1 = azimuth1*numpy.pi/180
2087
2101
2088 2102 for i in range(heightList.size):
2089 2103 h = heightList[i]
2090 2104 indH = numpy.where((metArray1[:,2] == h)&(numpy.abs(metArray1[:,-2]) < 100))[0]
@@ -2097,71 +2111,71 class WindProfiler(Operation):
2097 2111 A = numpy.asmatrix(A)
2098 2112 A1 = numpy.linalg.pinv(A.transpose()*A)*A.transpose()
2099 2113 velHor = numpy.dot(A1,velAux)
2100
2114
2101 2115 velEst[i,:] = numpy.squeeze(velHor)
2102 2116 return velEst
2103
2117
2104 2118 def __getPhaseSlope(self, metArray, heightList, timeList):
2105 2119 meteorList = []
2106 2120 #utctime sec1 height SNR velRad ph0 ph1 ph2 coh0 coh1 coh2
2107 2121 #Putting back together the meteor matrix
2108 2122 utctime = metArray[:,0]
2109 2123 uniqueTime = numpy.unique(utctime)
2110
2124
2111 2125 phaseDerThresh = 0.5
2112 2126 ippSeconds = timeList[1] - timeList[0]
2113 2127 sec = numpy.where(timeList>1)[0][0]
2114 2128 nPairs = metArray.shape[1] - 6
2115 2129 nHeights = len(heightList)
2116
2130
2117 2131 for t in uniqueTime:
2118 2132 metArray1 = metArray[utctime==t,:]
2119 2133 # phaseDerThresh = numpy.pi/4 #reducir Phase thresh
2120 2134 tmet = metArray1[:,1].astype(int)
2121 2135 hmet = metArray1[:,2].astype(int)
2122
2136
2123 2137 metPhase = numpy.zeros((nPairs, heightList.size, timeList.size - 1))
2124 2138 metPhase[:,:] = numpy.nan
2125 2139 metPhase[:,hmet,tmet] = metArray1[:,6:].T
2126
2140
2127 2141 #Delete short trails
2128 2142 metBool = ~numpy.isnan(metPhase[0,:,:])
2129 2143 heightVect = numpy.sum(metBool, axis = 1)
2130 2144 metBool[heightVect<sec,:] = False
2131 2145 metPhase[:,heightVect<sec,:] = numpy.nan
2132
2146
2133 2147 #Derivative
2134 2148 metDer = numpy.abs(metPhase[:,:,1:] - metPhase[:,:,:-1])
2135 2149 phDerAux = numpy.dstack((numpy.full((nPairs,nHeights,1), False, dtype=bool),metDer > phaseDerThresh))
2136 2150 metPhase[phDerAux] = numpy.nan
2137
2151
2138 2152 #--------------------------METEOR DETECTION -----------------------------------------
2139 2153 indMet = numpy.where(numpy.any(metBool,axis=1))[0]
2140
2154
2141 2155 for p in numpy.arange(nPairs):
2142 2156 phase = metPhase[p,:,:]
2143 2157 phDer = metDer[p,:,:]
2144
2158
2145 2159 for h in indMet:
2146 2160 height = heightList[h]
2147 2161 phase1 = phase[h,:] #82
2148 2162 phDer1 = phDer[h,:]
2149
2163
2150 2164 phase1[~numpy.isnan(phase1)] = numpy.unwrap(phase1[~numpy.isnan(phase1)]) #Unwrap
2151
2165
2152 2166 indValid = numpy.where(~numpy.isnan(phase1))[0]
2153 2167 initMet = indValid[0]
2154 2168 endMet = 0
2155
2169
2156 2170 for i in range(len(indValid)-1):
2157
2171
2158 2172 #Time difference
2159 2173 inow = indValid[i]
2160 2174 inext = indValid[i+1]
2161 2175 idiff = inext - inow
2162 2176 #Phase difference
2163 phDiff = numpy.abs(phase1[inext] - phase1[inow])
2164
2177 phDiff = numpy.abs(phase1[inext] - phase1[inow])
2178
2165 2179 if idiff>sec or phDiff>numpy.pi/4 or inext==indValid[-1]: #End of Meteor
2166 2180 sizeTrail = inow - initMet + 1
2167 2181 if sizeTrail>3*sec: #Too short meteors
@@ -2177,43 +2191,43 class WindProfiler(Operation):
2177 2191 vel = slope#*height*1000/(k*d)
2178 2192 estAux = numpy.array([utctime,p,height, vel, rsq])
2179 2193 meteorList.append(estAux)
2180 initMet = inext
2194 initMet = inext
2181 2195 metArray2 = numpy.array(meteorList)
2182
2196
2183 2197 return metArray2
2184
2198
2185 2199 def __calculateAzimuth1(self, rx_location, pairslist, azimuth0):
2186
2200
2187 2201 azimuth1 = numpy.zeros(len(pairslist))
2188 2202 dist = numpy.zeros(len(pairslist))
2189
2203
2190 2204 for i in range(len(rx_location)):
2191 2205 ch0 = pairslist[i][0]
2192 2206 ch1 = pairslist[i][1]
2193
2207
2194 2208 diffX = rx_location[ch0][0] - rx_location[ch1][0]
2195 2209 diffY = rx_location[ch0][1] - rx_location[ch1][1]
2196 2210 azimuth1[i] = numpy.arctan2(diffY,diffX)*180/numpy.pi
2197 2211 dist[i] = numpy.sqrt(diffX**2 + diffY**2)
2198
2212
2199 2213 azimuth1 -= azimuth0
2200 2214 return azimuth1, dist
2201
2215
2202 2216 def techniqueNSM_DBS(self, **kwargs):
2203 2217 metArray = kwargs['metArray']
2204 2218 heightList = kwargs['heightList']
2205 timeList = kwargs['timeList']
2219 timeList = kwargs['timeList']
2206 2220 azimuth = kwargs['azimuth']
2207 2221 theta_x = numpy.array(kwargs['theta_x'])
2208 2222 theta_y = numpy.array(kwargs['theta_y'])
2209
2223
2210 2224 utctime = metArray[:,0]
2211 2225 cmet = metArray[:,1].astype(int)
2212 2226 hmet = metArray[:,3].astype(int)
2213 2227 SNRmet = metArray[:,4]
2214 2228 vmet = metArray[:,5]
2215 2229 spcmet = metArray[:,6]
2216
2230
2217 2231 nChan = numpy.max(cmet) + 1
2218 2232 nHeights = len(heightList)
2219 2233
@@ -2229,20 +2243,20 class WindProfiler(Operation):
2229 2243
2230 2244 thisH = (h1met>=hmin) & (h1met<hmax) & (cmet!=2) & (SNRmet>8) & (vmet<50) & (spcmet<10)
2231 2245 indthisH = numpy.where(thisH)
2232
2246
2233 2247 if numpy.size(indthisH) > 3:
2234
2248
2235 2249 vel_aux = vmet[thisH]
2236 2250 chan_aux = cmet[thisH]
2237 2251 cosu_aux = dir_cosu[chan_aux]
2238 2252 cosv_aux = dir_cosv[chan_aux]
2239 2253 cosw_aux = dir_cosw[chan_aux]
2240
2241 nch = numpy.size(numpy.unique(chan_aux))
2254
2255 nch = numpy.size(numpy.unique(chan_aux))
2242 2256 if nch > 1:
2243 2257 A = self.__calculateMatA(cosu_aux, cosv_aux, cosw_aux, True)
2244 2258 velEst[i,:] = numpy.dot(A,vel_aux)
2245
2259
2246 2260 return velEst
2247 2261
2248 2262 def run(self, dataOut, technique, nHours=1, hmin=70, hmax=110, **kwargs):
@@ -2253,39 +2267,39 class WindProfiler(Operation):
2253 2267 # noise = dataOut.noise
2254 2268 heightList = dataOut.heightList
2255 2269 SNR = dataOut.data_SNR
2256
2270
2257 2271 if technique == 'DBS':
2258
2259 kwargs['velRadial'] = param[:,1,:] #Radial velocity
2272
2273 kwargs['velRadial'] = param[:,1,:] #Radial velocity
2260 2274 kwargs['heightList'] = heightList
2261 2275 kwargs['SNR'] = SNR
2262
2276
2263 2277 dataOut.data_output, dataOut.heightList, dataOut.data_SNR = self.techniqueDBS(kwargs) #DBS Function
2264 2278 dataOut.utctimeInit = dataOut.utctime
2265 2279 dataOut.outputInterval = dataOut.paramInterval
2266
2280
2267 2281 elif technique == 'SA':
2268
2282
2269 2283 #Parameters
2270 2284 # position_x = kwargs['positionX']
2271 2285 # position_y = kwargs['positionY']
2272 2286 # azimuth = kwargs['azimuth']
2273 #
2287 #
2274 2288 # if kwargs.has_key('crosspairsList'):
2275 2289 # pairs = kwargs['crosspairsList']
2276 2290 # else:
2277 # pairs = None
2278 #
2291 # pairs = None
2292 #
2279 2293 # if kwargs.has_key('correctFactor'):
2280 2294 # correctFactor = kwargs['correctFactor']
2281 2295 # else:
2282 2296 # correctFactor = 1
2283
2297
2284 2298 # tau = dataOut.data_param
2285 2299 # _lambda = dataOut.C/dataOut.frequency
2286 2300 # pairsList = dataOut.groupList
2287 2301 # nChannels = dataOut.nChannels
2288
2302
2289 2303 kwargs['groupList'] = dataOut.groupList
2290 2304 kwargs['tau'] = dataOut.data_param
2291 2305 kwargs['_lambda'] = dataOut.C/dataOut.frequency
@@ -2293,30 +2307,30 class WindProfiler(Operation):
2293 2307 dataOut.data_output = self.techniqueSA(kwargs)
2294 2308 dataOut.utctimeInit = dataOut.utctime
2295 2309 dataOut.outputInterval = dataOut.timeInterval
2296
2297 elif technique == 'Meteors':
2310
2311 elif technique == 'Meteors':
2298 2312 dataOut.flagNoData = True
2299 2313 self.__dataReady = False
2300
2314
2301 2315 if 'nHours' in kwargs:
2302 2316 nHours = kwargs['nHours']
2303 else:
2317 else:
2304 2318 nHours = 1
2305
2319
2306 2320 if 'meteorsPerBin' in kwargs:
2307 2321 meteorThresh = kwargs['meteorsPerBin']
2308 2322 else:
2309 2323 meteorThresh = 6
2310
2324
2311 2325 if 'hmin' in kwargs:
2312 2326 hmin = kwargs['hmin']
2313 2327 else: hmin = 70
2314 2328 if 'hmax' in kwargs:
2315 2329 hmax = kwargs['hmax']
2316 2330 else: hmax = 110
2317
2331
2318 2332 dataOut.outputInterval = nHours*3600
2319
2333
2320 2334 if self.__isConfig == False:
2321 2335 # self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
2322 2336 #Get Initial LTC time
@@ -2324,29 +2338,29 class WindProfiler(Operation):
2324 2338 self.__initime = (self.__initime.replace(minute = 0, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
2325 2339
2326 2340 self.__isConfig = True
2327
2341
2328 2342 if self.__buffer is None:
2329 2343 self.__buffer = dataOut.data_param
2330 2344 self.__firstdata = copy.copy(dataOut)
2331 2345
2332 2346 else:
2333 2347 self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
2334
2348
2335 2349 self.__checkTime(dataOut.utctime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
2336
2350
2337 2351 if self.__dataReady:
2338 2352 dataOut.utctimeInit = self.__initime
2339
2353
2340 2354 self.__initime += dataOut.outputInterval #to erase time offset
2341
2355
2342 2356 dataOut.data_output, dataOut.heightList = self.techniqueMeteors(self.__buffer, meteorThresh, hmin, hmax)
2343 2357 dataOut.flagNoData = False
2344 2358 self.__buffer = None
2345
2359
2346 2360 elif technique == 'Meteors1':
2347 2361 dataOut.flagNoData = True
2348 2362 self.__dataReady = False
2349
2363
2350 2364 if 'nMins' in kwargs:
2351 2365 nMins = kwargs['nMins']
2352 2366 else: nMins = 20
@@ -2361,7 +2375,7 class WindProfiler(Operation):
2361 2375 if 'mode' in kwargs:
2362 2376 mode = kwargs['mode']
2363 2377 if 'theta_x' in kwargs:
2364 theta_x = kwargs['theta_x']
2378 theta_x = kwargs['theta_x']
2365 2379 if 'theta_y' in kwargs:
2366 2380 theta_y = kwargs['theta_y']
2367 2381 else: mode = 'SA'
@@ -2374,10 +2388,10 class WindProfiler(Operation):
2374 2388 freq = 50e6
2375 2389 lamb = C/freq
2376 2390 k = 2*numpy.pi/lamb
2377
2391
2378 2392 timeList = dataOut.abscissaList
2379 2393 heightList = dataOut.heightList
2380
2394
2381 2395 if self.__isConfig == False:
2382 2396 dataOut.outputInterval = nMins*60
2383 2397 # self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
@@ -2388,20 +2402,20 class WindProfiler(Operation):
2388 2402 self.__initime = (initime.replace(minute = minuteNew, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
2389 2403
2390 2404 self.__isConfig = True
2391
2405
2392 2406 if self.__buffer is None:
2393 2407 self.__buffer = dataOut.data_param
2394 2408 self.__firstdata = copy.copy(dataOut)
2395 2409
2396 2410 else:
2397 2411 self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
2398
2412
2399 2413 self.__checkTime(dataOut.utctime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
2400
2414
2401 2415 if self.__dataReady:
2402 2416 dataOut.utctimeInit = self.__initime
2403 2417 self.__initime += dataOut.outputInterval #to erase time offset
2404
2418
2405 2419 metArray = self.__buffer
2406 2420 if mode == 'SA':
2407 2421 dataOut.data_output = self.techniqueNSM_SA(rx_location=rx_location, groupList=groupList, azimuth=azimuth, dfactor=dfactor, k=k,metArray=metArray, heightList=heightList,timeList=timeList)
@@ -2412,71 +2426,71 class WindProfiler(Operation):
2412 2426 self.__buffer = None
2413 2427
2414 2428 return
2415
2429
2416 2430 class EWDriftsEstimation(Operation):
2417
2418 def __init__(self):
2419 Operation.__init__(self)
2420
2431
2432 def __init__(self):
2433 Operation.__init__(self)
2434
2421 2435 def __correctValues(self, heiRang, phi, velRadial, SNR):
2422 2436 listPhi = phi.tolist()
2423 2437 maxid = listPhi.index(max(listPhi))
2424 2438 minid = listPhi.index(min(listPhi))
2425
2426 rango = list(range(len(phi)))
2439
2440 rango = list(range(len(phi)))
2427 2441 # rango = numpy.delete(rango,maxid)
2428
2442
2429 2443 heiRang1 = heiRang*math.cos(phi[maxid])
2430 2444 heiRangAux = heiRang*math.cos(phi[minid])
2431 2445 indOut = (heiRang1 < heiRangAux[0]).nonzero()
2432 2446 heiRang1 = numpy.delete(heiRang1,indOut)
2433
2447
2434 2448 velRadial1 = numpy.zeros([len(phi),len(heiRang1)])
2435 2449 SNR1 = numpy.zeros([len(phi),len(heiRang1)])
2436
2450
2437 2451 for i in rango:
2438 2452 x = heiRang*math.cos(phi[i])
2439 2453 y1 = velRadial[i,:]
2440 2454 f1 = interpolate.interp1d(x,y1,kind = 'cubic')
2441
2455
2442 2456 x1 = heiRang1
2443 2457 y11 = f1(x1)
2444
2458
2445 2459 y2 = SNR[i,:]
2446 2460 f2 = interpolate.interp1d(x,y2,kind = 'cubic')
2447 2461 y21 = f2(x1)
2448
2462
2449 2463 velRadial1[i,:] = y11
2450 2464 SNR1[i,:] = y21
2451
2465
2452 2466 return heiRang1, velRadial1, SNR1
2453 2467
2454 2468 def run(self, dataOut, zenith, zenithCorrection):
2455 2469 heiRang = dataOut.heightList
2456 2470 velRadial = dataOut.data_param[:,3,:]
2457 2471 SNR = dataOut.data_SNR
2458
2472
2459 2473 zenith = numpy.array(zenith)
2460 zenith -= zenithCorrection
2474 zenith -= zenithCorrection
2461 2475 zenith *= numpy.pi/180
2462
2476
2463 2477 heiRang1, velRadial1, SNR1 = self.__correctValues(heiRang, numpy.abs(zenith), velRadial, SNR)
2464
2478
2465 2479 alp = zenith[0]
2466 2480 bet = zenith[1]
2467
2481
2468 2482 w_w = velRadial1[0,:]
2469 2483 w_e = velRadial1[1,:]
2470
2471 w = (w_w*numpy.sin(bet) - w_e*numpy.sin(alp))/(numpy.cos(alp)*numpy.sin(bet) - numpy.cos(bet)*numpy.sin(alp))
2472 u = (w_w*numpy.cos(bet) - w_e*numpy.cos(alp))/(numpy.sin(alp)*numpy.cos(bet) - numpy.sin(bet)*numpy.cos(alp))
2473
2484
2485 w = (w_w*numpy.sin(bet) - w_e*numpy.sin(alp))/(numpy.cos(alp)*numpy.sin(bet) - numpy.cos(bet)*numpy.sin(alp))
2486 u = (w_w*numpy.cos(bet) - w_e*numpy.cos(alp))/(numpy.sin(alp)*numpy.cos(bet) - numpy.sin(bet)*numpy.cos(alp))
2487
2474 2488 winds = numpy.vstack((u,w))
2475
2489
2476 2490 dataOut.heightList = heiRang1
2477 2491 dataOut.data_output = winds
2478 2492 dataOut.data_SNR = SNR1
2479
2493
2480 2494 dataOut.utctimeInit = dataOut.utctime
2481 2495 dataOut.outputInterval = dataOut.timeInterval
2482 2496 return
@@ -2489,11 +2503,11 class NonSpecularMeteorDetection(Operation):
2489 2503 data_acf = dataOut.data_pre[0]
2490 2504 data_ccf = dataOut.data_pre[1]
2491 2505 pairsList = dataOut.groupList[1]
2492
2506
2493 2507 lamb = dataOut.C/dataOut.frequency
2494 2508 tSamp = dataOut.ippSeconds*dataOut.nCohInt
2495 2509 paramInterval = dataOut.paramInterval
2496
2510
2497 2511 nChannels = data_acf.shape[0]
2498 2512 nLags = data_acf.shape[1]
2499 2513 nProfiles = data_acf.shape[2]
@@ -2503,7 +2517,7 class NonSpecularMeteorDetection(Operation):
2503 2517 heightList = dataOut.heightList
2504 2518 ippSeconds = dataOut.ippSeconds*dataOut.nCohInt*dataOut.nAvg
2505 2519 utctime = dataOut.utctime
2506
2520
2507 2521 dataOut.abscissaList = numpy.arange(0,paramInterval+ippSeconds,ippSeconds)
2508 2522
2509 2523 #------------------------ SNR --------------------------------------
@@ -2515,7 +2529,7 class NonSpecularMeteorDetection(Operation):
2515 2529 SNR[i] = (power[i]-noise[i])/noise[i]
2516 2530 SNRm = numpy.nanmean(SNR, axis = 0)
2517 2531 SNRdB = 10*numpy.log10(SNR)
2518
2532
2519 2533 if mode == 'SA':
2520 2534 dataOut.groupList = dataOut.groupList[1]
2521 2535 nPairs = data_ccf.shape[0]
@@ -2523,22 +2537,22 class NonSpecularMeteorDetection(Operation):
2523 2537 phase = numpy.zeros(data_ccf[:,0,:,:].shape)
2524 2538 # phase1 = numpy.copy(phase)
2525 2539 coh1 = numpy.zeros(data_ccf[:,0,:,:].shape)
2526
2540
2527 2541 for p in range(nPairs):
2528 2542 ch0 = pairsList[p][0]
2529 2543 ch1 = pairsList[p][1]
2530 2544 ccf = data_ccf[p,0,:,:]/numpy.sqrt(data_acf[ch0,0,:,:]*data_acf[ch1,0,:,:])
2531 phase[p,:,:] = ndimage.median_filter(numpy.angle(ccf), size = (5,1)) #median filter
2532 # phase1[p,:,:] = numpy.angle(ccf) #median filter
2533 coh1[p,:,:] = ndimage.median_filter(numpy.abs(ccf), 5) #median filter
2534 # coh1[p,:,:] = numpy.abs(ccf) #median filter
2545 phase[p,:,:] = ndimage.median_filter(numpy.angle(ccf), size = (5,1)) #median filter
2546 # phase1[p,:,:] = numpy.angle(ccf) #median filter
2547 coh1[p,:,:] = ndimage.median_filter(numpy.abs(ccf), 5) #median filter
2548 # coh1[p,:,:] = numpy.abs(ccf) #median filter
2535 2549 coh = numpy.nanmax(coh1, axis = 0)
2536 2550 # struc = numpy.ones((5,1))
2537 2551 # coh = ndimage.morphology.grey_dilation(coh, size=(10,1))
2538 2552 #---------------------- Radial Velocity ----------------------------
2539 2553 phaseAux = numpy.mean(numpy.angle(data_acf[:,1,:,:]), axis = 0)
2540 2554 velRad = phaseAux*lamb/(4*numpy.pi*tSamp)
2541
2555
2542 2556 if allData:
2543 2557 boolMetFin = ~numpy.isnan(SNRm)
2544 2558 # coh[:-1,:] = numpy.nanmean(numpy.abs(phase[:,1:,:] - phase[:,:-1,:]),axis=0)
@@ -2546,31 +2560,31 class NonSpecularMeteorDetection(Operation):
2546 2560 #------------------------ Meteor mask ---------------------------------
2547 2561 # #SNR mask
2548 2562 # boolMet = (SNRdB>SNRthresh)#|(~numpy.isnan(SNRdB))
2549 #
2563 #
2550 2564 # #Erase small objects
2551 # boolMet1 = self.__erase_small(boolMet, 2*sec, 5)
2552 #
2565 # boolMet1 = self.__erase_small(boolMet, 2*sec, 5)
2566 #
2553 2567 # auxEEJ = numpy.sum(boolMet1,axis=0)
2554 2568 # indOver = auxEEJ>nProfiles*0.8 #Use this later
2555 2569 # indEEJ = numpy.where(indOver)[0]
2556 2570 # indNEEJ = numpy.where(~indOver)[0]
2557 #
2571 #
2558 2572 # boolMetFin = boolMet1
2559 #
2573 #
2560 2574 # if indEEJ.size > 0:
2561 # boolMet1[:,indEEJ] = False #Erase heights with EEJ
2562 #
2575 # boolMet1[:,indEEJ] = False #Erase heights with EEJ
2576 #
2563 2577 # boolMet2 = coh > cohThresh
2564 2578 # boolMet2 = self.__erase_small(boolMet2, 2*sec,5)
2565 #
2579 #
2566 2580 # #Final Meteor mask
2567 2581 # boolMetFin = boolMet1|boolMet2
2568
2582
2569 2583 #Coherence mask
2570 2584 boolMet1 = coh > 0.75
2571 2585 struc = numpy.ones((30,1))
2572 2586 boolMet1 = ndimage.morphology.binary_dilation(boolMet1, structure=struc)
2573
2587
2574 2588 #Derivative mask
2575 2589 derPhase = numpy.nanmean(numpy.abs(phase[:,1:,:] - phase[:,:-1,:]),axis=0)
2576 2590 boolMet2 = derPhase < 0.2
@@ -2587,7 +2601,7 class NonSpecularMeteorDetection(Operation):
2587 2601
2588 2602 tmet = coordMet[0]
2589 2603 hmet = coordMet[1]
2590
2604
2591 2605 data_param = numpy.zeros((tmet.size, 6 + nPairs))
2592 2606 data_param[:,0] = utctime
2593 2607 data_param[:,1] = tmet
@@ -2596,7 +2610,7 class NonSpecularMeteorDetection(Operation):
2596 2610 data_param[:,4] = velRad[tmet,hmet]
2597 2611 data_param[:,5] = coh[tmet,hmet]
2598 2612 data_param[:,6:] = phase[:,tmet,hmet].T
2599
2613
2600 2614 elif mode == 'DBS':
2601 2615 dataOut.groupList = numpy.arange(nChannels)
2602 2616
@@ -2604,7 +2618,7 class NonSpecularMeteorDetection(Operation):
2604 2618 phase = numpy.angle(data_acf[:,1,:,:])
2605 2619 # phase = ndimage.median_filter(numpy.angle(data_acf[:,1,:,:]), size = (1,5,1))
2606 2620 velRad = phase*lamb/(4*numpy.pi*tSamp)
2607
2621
2608 2622 #Spectral width
2609 2623 # acf1 = ndimage.median_filter(numpy.abs(data_acf[:,1,:,:]), size = (1,5,1))
2610 2624 # acf2 = ndimage.median_filter(numpy.abs(data_acf[:,2,:,:]), size = (1,5,1))
@@ -2619,24 +2633,24 class NonSpecularMeteorDetection(Operation):
2619 2633 #SNR
2620 2634 boolMet1 = (SNRdB>SNRthresh) #SNR mask
2621 2635 boolMet1 = ndimage.median_filter(boolMet1, size=(1,5,5))
2622
2636
2623 2637 #Radial velocity
2624 2638 boolMet2 = numpy.abs(velRad) < 20
2625 2639 boolMet2 = ndimage.median_filter(boolMet2, (1,5,5))
2626
2640
2627 2641 #Spectral Width
2628 2642 boolMet3 = spcWidth < 30
2629 2643 boolMet3 = ndimage.median_filter(boolMet3, (1,5,5))
2630 2644 # boolMetFin = self.__erase_small(boolMet1, 10,5)
2631 2645 boolMetFin = boolMet1&boolMet2&boolMet3
2632
2646
2633 2647 #Creating data_param
2634 2648 coordMet = numpy.where(boolMetFin)
2635 2649
2636 2650 cmet = coordMet[0]
2637 2651 tmet = coordMet[1]
2638 2652 hmet = coordMet[2]
2639
2653
2640 2654 data_param = numpy.zeros((tmet.size, 7))
2641 2655 data_param[:,0] = utctime
2642 2656 data_param[:,1] = cmet
@@ -2645,7 +2659,7 class NonSpecularMeteorDetection(Operation):
2645 2659 data_param[:,4] = SNR[cmet,tmet,hmet].T
2646 2660 data_param[:,5] = velRad[cmet,tmet,hmet].T
2647 2661 data_param[:,6] = spcWidth[cmet,tmet,hmet].T
2648
2662
2649 2663 # self.dataOut.data_param = data_int
2650 2664 if len(data_param) == 0:
2651 2665 dataOut.flagNoData = True
@@ -2655,21 +2669,21 class NonSpecularMeteorDetection(Operation):
2655 2669 def __erase_small(self, binArray, threshX, threshY):
2656 2670 labarray, numfeat = ndimage.measurements.label(binArray)
2657 2671 binArray1 = numpy.copy(binArray)
2658
2672
2659 2673 for i in range(1,numfeat + 1):
2660 2674 auxBin = (labarray==i)
2661 2675 auxSize = auxBin.sum()
2662
2676
2663 2677 x,y = numpy.where(auxBin)
2664 2678 widthX = x.max() - x.min()
2665 2679 widthY = y.max() - y.min()
2666
2680
2667 2681 #width X: 3 seg -> 12.5*3
2668 #width Y:
2669
2682 #width Y:
2683
2670 2684 if (auxSize < 50) or (widthX < threshX) or (widthY < threshY):
2671 2685 binArray1[auxBin] = False
2672
2686
2673 2687 return binArray1
2674 2688
2675 2689 #--------------- Specular Meteor ----------------
@@ -2679,36 +2693,36 class SMDetection(Operation):
2679 2693 Function DetectMeteors()
2680 2694 Project developed with paper:
2681 2695 HOLDSWORTH ET AL. 2004
2682
2696
2683 2697 Input:
2684 2698 self.dataOut.data_pre
2685
2699
2686 2700 centerReceiverIndex: From the channels, which is the center receiver
2687
2701
2688 2702 hei_ref: Height reference for the Beacon signal extraction
2689 2703 tauindex:
2690 2704 predefinedPhaseShifts: Predefined phase offset for the voltge signals
2691
2705
2692 2706 cohDetection: Whether to user Coherent detection or not
2693 2707 cohDet_timeStep: Coherent Detection calculation time step
2694 2708 cohDet_thresh: Coherent Detection phase threshold to correct phases
2695
2709
2696 2710 noise_timeStep: Noise calculation time step
2697 2711 noise_multiple: Noise multiple to define signal threshold
2698
2712
2699 2713 multDet_timeLimit: Multiple Detection Removal time limit in seconds
2700 2714 multDet_rangeLimit: Multiple Detection Removal range limit in km
2701
2715
2702 2716 phaseThresh: Maximum phase difference between receiver to be consider a meteor
2703 SNRThresh: Minimum SNR threshold of the meteor signal to be consider a meteor
2704
2717 SNRThresh: Minimum SNR threshold of the meteor signal to be consider a meteor
2718
2705 2719 hmin: Minimum Height of the meteor to use it in the further wind estimations
2706 2720 hmax: Maximum Height of the meteor to use it in the further wind estimations
2707 2721 azimuth: Azimuth angle correction
2708
2722
2709 2723 Affected:
2710 2724 self.dataOut.data_param
2711
2725
2712 2726 Rejection Criteria (Errors):
2713 2727 0: No error; analysis OK
2714 2728 1: SNR < SNR threshold
@@ -2727,9 +2741,9 class SMDetection(Operation):
2727 2741 14: height ambiguous echo: more then one possible height within 70 to 110 km
2728 2742 15: radial drift velocity or projected horizontal velocity exceeds 200 m/s
2729 2743 16: oscilatory echo, indicating event most likely not an underdense echo
2730
2744
2731 2745 17: phase difference in meteor Reestimation
2732
2746
2733 2747 Data Storage:
2734 2748 Meteors for Wind Estimation (8):
2735 2749 Utc Time | Range Height
@@ -2737,19 +2751,19 class SMDetection(Operation):
2737 2751 VelRad errorVelRad
2738 2752 Phase0 Phase1 Phase2 Phase3
2739 2753 TypeError
2740
2741 '''
2742
2754
2755 '''
2756
2743 2757 def run(self, dataOut, hei_ref = None, tauindex = 0,
2744 2758 phaseOffsets = None,
2745 cohDetection = False, cohDet_timeStep = 1, cohDet_thresh = 25,
2759 cohDetection = False, cohDet_timeStep = 1, cohDet_thresh = 25,
2746 2760 noise_timeStep = 4, noise_multiple = 4,
2747 2761 multDet_timeLimit = 1, multDet_rangeLimit = 3,
2748 2762 phaseThresh = 20, SNRThresh = 5,
2749 2763 hmin = 50, hmax=150, azimuth = 0,
2750 2764 channelPositions = None) :
2751
2752
2765
2766
2753 2767 #Getting Pairslist
2754 2768 if channelPositions is None:
2755 2769 # channelPositions = [(2.5,0), (0,2.5), (0,0), (0,4.5), (-2,0)] #T
@@ -2759,53 +2773,53 class SMDetection(Operation):
2759 2773 heiRang = dataOut.getHeiRange()
2760 2774 #Get Beacon signal - No Beacon signal anymore
2761 2775 # newheis = numpy.where(self.dataOut.heightList>self.dataOut.radarControllerHeaderObj.Taus[tauindex])
2762 #
2776 #
2763 2777 # if hei_ref != None:
2764 2778 # newheis = numpy.where(self.dataOut.heightList>hei_ref)
2765 #
2766
2767
2779 #
2780
2781
2768 2782 #****************REMOVING HARDWARE PHASE DIFFERENCES***************
2769 2783 # see if the user put in pre defined phase shifts
2770 2784 voltsPShift = dataOut.data_pre.copy()
2771
2785
2772 2786 # if predefinedPhaseShifts != None:
2773 2787 # hardwarePhaseShifts = numpy.array(predefinedPhaseShifts)*numpy.pi/180
2774 #
2788 #
2775 2789 # # elif beaconPhaseShifts:
2776 2790 # # #get hardware phase shifts using beacon signal
2777 2791 # # hardwarePhaseShifts = self.__getHardwarePhaseDiff(self.dataOut.data_pre, pairslist, newheis, 10)
2778 2792 # # hardwarePhaseShifts = numpy.insert(hardwarePhaseShifts,centerReceiverIndex,0)
2779 #
2793 #
2780 2794 # else:
2781 # hardwarePhaseShifts = numpy.zeros(5)
2782 #
2795 # hardwarePhaseShifts = numpy.zeros(5)
2796 #
2783 2797 # voltsPShift = numpy.zeros((self.dataOut.data_pre.shape[0],self.dataOut.data_pre.shape[1],self.dataOut.data_pre.shape[2]), dtype = 'complex')
2784 2798 # for i in range(self.dataOut.data_pre.shape[0]):
2785 2799 # voltsPShift[i,:,:] = self.__shiftPhase(self.dataOut.data_pre[i,:,:], hardwarePhaseShifts[i])
2786 2800
2787 2801 #******************END OF REMOVING HARDWARE PHASE DIFFERENCES*********
2788
2802
2789 2803 #Remove DC
2790 2804 voltsDC = numpy.mean(voltsPShift,1)
2791 2805 voltsDC = numpy.mean(voltsDC,1)
2792 2806 for i in range(voltsDC.shape[0]):
2793 2807 voltsPShift[i] = voltsPShift[i] - voltsDC[i]
2794
2795 #Don't considerate last heights, theyre used to calculate Hardware Phase Shift
2808
2809 #Don't considerate last heights, theyre used to calculate Hardware Phase Shift
2796 2810 # voltsPShift = voltsPShift[:,:,:newheis[0][0]]
2797
2811
2798 2812 #************ FIND POWER OF DATA W/COH OR NON COH DETECTION (3.4) **********
2799 2813 #Coherent Detection
2800 2814 if cohDetection:
2801 2815 #use coherent detection to get the net power
2802 2816 cohDet_thresh = cohDet_thresh*numpy.pi/180
2803 2817 voltsPShift = self.__coherentDetection(voltsPShift, cohDet_timeStep, dataOut.timeInterval, pairslist0, cohDet_thresh)
2804
2818
2805 2819 #Non-coherent detection!
2806 2820 powerNet = numpy.nansum(numpy.abs(voltsPShift[:,:,:])**2,0)
2807 2821 #********** END OF COH/NON-COH POWER CALCULATION**********************
2808
2822
2809 2823 #********** FIND THE NOISE LEVEL AND POSSIBLE METEORS ****************
2810 2824 #Get noise
2811 2825 noise, noise1 = self.__getNoise(powerNet, noise_timeStep, dataOut.timeInterval)
@@ -2815,7 +2829,7 class SMDetection(Operation):
2815 2829 #Meteor echoes detection
2816 2830 listMeteors = self.__findMeteors(powerNet, signalThresh)
2817 2831 #******* END OF NOISE LEVEL AND POSSIBLE METEORS CACULATION **********
2818
2832
2819 2833 #************** REMOVE MULTIPLE DETECTIONS (3.5) ***************************
2820 2834 #Parameters
2821 2835 heiRange = dataOut.getHeiRange()
@@ -2825,7 +2839,7 class SMDetection(Operation):
2825 2839 #Multiple detection removals
2826 2840 listMeteors1 = self.__removeMultipleDetections(listMeteors, rangeLimit, timeLimit)
2827 2841 #************ END OF REMOVE MULTIPLE DETECTIONS **********************
2828
2842
2829 2843 #********************* METEOR REESTIMATION (3.7, 3.8, 3.9, 3.10) ********************
2830 2844 #Parameters
2831 2845 phaseThresh = phaseThresh*numpy.pi/180
@@ -2836,40 +2850,40 class SMDetection(Operation):
2836 2850 #Estimation of decay times (Errors N 7, 8, 11)
2837 2851 listMeteors3 = self.__estimateDecayTime(listMeteors2, listMeteorsPower, dataOut.timeInterval, dataOut.frequency)
2838 2852 #******************* END OF METEOR REESTIMATION *******************
2839
2853
2840 2854 #********************* METEOR PARAMETERS CALCULATION (3.11, 3.12, 3.13) **************************
2841 2855 #Calculating Radial Velocity (Error N 15)
2842 2856 radialStdThresh = 10
2843 listMeteors4 = self.__getRadialVelocity(listMeteors3, listMeteorsVolts, radialStdThresh, pairslist0, dataOut.timeInterval)
2857 listMeteors4 = self.__getRadialVelocity(listMeteors3, listMeteorsVolts, radialStdThresh, pairslist0, dataOut.timeInterval)
2844 2858
2845 2859 if len(listMeteors4) > 0:
2846 2860 #Setting New Array
2847 2861 date = dataOut.utctime
2848 2862 arrayParameters = self.__setNewArrays(listMeteors4, date, heiRang)
2849
2863
2850 2864 #Correcting phase offset
2851 2865 if phaseOffsets != None:
2852 2866 phaseOffsets = numpy.array(phaseOffsets)*numpy.pi/180
2853 2867 arrayParameters[:,8:12] = numpy.unwrap(arrayParameters[:,8:12] + phaseOffsets)
2854
2868
2855 2869 #Second Pairslist
2856 2870 pairsList = []
2857 2871 pairx = (0,1)
2858 2872 pairy = (2,3)
2859 2873 pairsList.append(pairx)
2860 2874 pairsList.append(pairy)
2861
2875
2862 2876 jph = numpy.array([0,0,0,0])
2863 2877 h = (hmin,hmax)
2864 2878 arrayParameters = meteorOps.getMeteorParams(arrayParameters, azimuth, h, pairsList, distances, jph)
2865
2879
2866 2880 # #Calculate AOA (Error N 3, 4)
2867 2881 # #JONES ET AL. 1998
2868 2882 # error = arrayParameters[:,-1]
2869 2883 # AOAthresh = numpy.pi/8
2870 2884 # phases = -arrayParameters[:,9:13]
2871 2885 # arrayParameters[:,4:7], arrayParameters[:,-1] = meteorOps.getAOA(phases, pairsList, error, AOAthresh, azimuth)
2872 #
2886 #
2873 2887 # #Calculate Heights (Error N 13 and 14)
2874 2888 # error = arrayParameters[:,-1]
2875 2889 # Ranges = arrayParameters[:,2]
@@ -2877,73 +2891,73 class SMDetection(Operation):
2877 2891 # arrayParameters[:,3], arrayParameters[:,-1] = meteorOps.getHeights(Ranges, zenith, error, hmin, hmax)
2878 2892 # error = arrayParameters[:,-1]
2879 2893 #********************* END OF PARAMETERS CALCULATION **************************
2880
2881 #***************************+ PASS DATA TO NEXT STEP **********************
2894
2895 #***************************+ PASS DATA TO NEXT STEP **********************
2882 2896 # arrayFinal = arrayParameters.reshape((1,arrayParameters.shape[0],arrayParameters.shape[1]))
2883 2897 dataOut.data_param = arrayParameters
2884
2898
2885 2899 if arrayParameters is None:
2886 2900 dataOut.flagNoData = True
2887 2901 else:
2888 2902 dataOut.flagNoData = True
2889
2903
2890 2904 return
2891
2905
2892 2906 def __getHardwarePhaseDiff(self, voltage0, pairslist, newheis, n):
2893
2907
2894 2908 minIndex = min(newheis[0])
2895 2909 maxIndex = max(newheis[0])
2896
2910
2897 2911 voltage = voltage0[:,:,minIndex:maxIndex+1]
2898 2912 nLength = voltage.shape[1]/n
2899 2913 nMin = 0
2900 2914 nMax = 0
2901 2915 phaseOffset = numpy.zeros((len(pairslist),n))
2902
2916
2903 2917 for i in range(n):
2904 2918 nMax += nLength
2905 2919 phaseCCF = -numpy.angle(self.__calculateCCF(voltage[:,nMin:nMax,:], pairslist, [0]))
2906 2920 phaseCCF = numpy.mean(phaseCCF, axis = 2)
2907 phaseOffset[:,i] = phaseCCF.transpose()
2921 phaseOffset[:,i] = phaseCCF.transpose()
2908 2922 nMin = nMax
2909 2923 # phaseDiff, phaseArrival = self.estimatePhaseDifference(voltage, pairslist)
2910
2924
2911 2925 #Remove Outliers
2912 2926 factor = 2
2913 2927 wt = phaseOffset - signal.medfilt(phaseOffset,(1,5))
2914 2928 dw = numpy.std(wt,axis = 1)
2915 2929 dw = dw.reshape((dw.size,1))
2916 ind = numpy.where(numpy.logical_or(wt>dw*factor,wt<-dw*factor))
2930 ind = numpy.where(numpy.logical_or(wt>dw*factor,wt<-dw*factor))
2917 2931 phaseOffset[ind] = numpy.nan
2918 phaseOffset = stats.nanmean(phaseOffset, axis=1)
2919
2932 phaseOffset = stats.nanmean(phaseOffset, axis=1)
2933
2920 2934 return phaseOffset
2921
2935
2922 2936 def __shiftPhase(self, data, phaseShift):
2923 2937 #this will shift the phase of a complex number
2924 dataShifted = numpy.abs(data) * numpy.exp((numpy.angle(data)+phaseShift)*1j)
2938 dataShifted = numpy.abs(data) * numpy.exp((numpy.angle(data)+phaseShift)*1j)
2925 2939 return dataShifted
2926
2940
2927 2941 def __estimatePhaseDifference(self, array, pairslist):
2928 2942 nChannel = array.shape[0]
2929 2943 nHeights = array.shape[2]
2930 2944 numPairs = len(pairslist)
2931 2945 # phaseCCF = numpy.zeros((nChannel, 5, nHeights))
2932 2946 phaseCCF = numpy.angle(self.__calculateCCF(array, pairslist, [-2,-1,0,1,2]))
2933
2947
2934 2948 #Correct phases
2935 2949 derPhaseCCF = phaseCCF[:,1:,:] - phaseCCF[:,0:-1,:]
2936 2950 indDer = numpy.where(numpy.abs(derPhaseCCF) > numpy.pi)
2937
2938 if indDer[0].shape[0] > 0:
2951
2952 if indDer[0].shape[0] > 0:
2939 2953 for i in range(indDer[0].shape[0]):
2940 2954 signo = -numpy.sign(derPhaseCCF[indDer[0][i],indDer[1][i],indDer[2][i]])
2941 2955 phaseCCF[indDer[0][i],indDer[1][i]+1:,:] += signo*2*numpy.pi
2942
2956
2943 2957 # for j in range(numSides):
2944 2958 # phaseCCFAux = self.calculateCCF(arrayCenter, arraySides[j,:,:], [-2,1,0,1,2])
2945 2959 # phaseCCF[j,:,:] = numpy.angle(phaseCCFAux)
2946 #
2960 #
2947 2961 #Linear
2948 2962 phaseInt = numpy.zeros((numPairs,1))
2949 2963 angAllCCF = phaseCCF[:,[0,1,3,4],0]
@@ -2953,16 +2967,16 class SMDetection(Operation):
2953 2967 #Phase Differences
2954 2968 phaseDiff = phaseInt - phaseCCF[:,2,:]
2955 2969 phaseArrival = phaseInt.reshape(phaseInt.size)
2956
2970
2957 2971 #Dealias
2958 2972 phaseArrival = numpy.angle(numpy.exp(1j*phaseArrival))
2959 2973 # indAlias = numpy.where(phaseArrival > numpy.pi)
2960 2974 # phaseArrival[indAlias] -= 2*numpy.pi
2961 2975 # indAlias = numpy.where(phaseArrival < -numpy.pi)
2962 2976 # phaseArrival[indAlias] += 2*numpy.pi
2963
2977
2964 2978 return phaseDiff, phaseArrival
2965
2979
2966 2980 def __coherentDetection(self, volts, timeSegment, timeInterval, pairslist, thresh):
2967 2981 #this function will run the coherent detection used in Holdworth et al. 2004 and return the net power
2968 2982 #find the phase shifts of each channel over 1 second intervals
@@ -2972,25 +2986,25 class SMDetection(Operation):
2972 2986 numHeights = volts.shape[2]
2973 2987 nChannel = volts.shape[0]
2974 2988 voltsCohDet = volts.copy()
2975
2989
2976 2990 pairsarray = numpy.array(pairslist)
2977 2991 indSides = pairsarray[:,1]
2978 2992 # indSides = numpy.array(range(nChannel))
2979 2993 # indSides = numpy.delete(indSides, indCenter)
2980 #
2994 #
2981 2995 # listCenter = numpy.array_split(volts[indCenter,:,:], numBlocks, 0)
2982 2996 listBlocks = numpy.array_split(volts, numBlocks, 1)
2983
2997
2984 2998 startInd = 0
2985 2999 endInd = 0
2986
3000
2987 3001 for i in range(numBlocks):
2988 3002 startInd = endInd
2989 endInd = endInd + listBlocks[i].shape[1]
2990
3003 endInd = endInd + listBlocks[i].shape[1]
3004
2991 3005 arrayBlock = listBlocks[i]
2992 3006 # arrayBlockCenter = listCenter[i]
2993
3007
2994 3008 #Estimate the Phase Difference
2995 3009 phaseDiff, aux = self.__estimatePhaseDifference(arrayBlock, pairslist)
2996 3010 #Phase Difference RMS
@@ -3002,21 +3016,21 class SMDetection(Operation):
3002 3016 for j in range(indSides.size):
3003 3017 arrayBlock[indSides[j],:,indPhase] = self.__shiftPhase(arrayBlock[indSides[j],:,indPhase], phaseDiff[j,indPhase].transpose())
3004 3018 voltsCohDet[:,startInd:endInd,:] = arrayBlock
3005
3019
3006 3020 return voltsCohDet
3007
3021
3008 3022 def __calculateCCF(self, volts, pairslist ,laglist):
3009
3023
3010 3024 nHeights = volts.shape[2]
3011 nPoints = volts.shape[1]
3025 nPoints = volts.shape[1]
3012 3026 voltsCCF = numpy.zeros((len(pairslist), len(laglist), nHeights),dtype = 'complex')
3013
3027
3014 3028 for i in range(len(pairslist)):
3015 3029 volts1 = volts[pairslist[i][0]]
3016 volts2 = volts[pairslist[i][1]]
3017
3030 volts2 = volts[pairslist[i][1]]
3031
3018 3032 for t in range(len(laglist)):
3019 idxT = laglist[t]
3033 idxT = laglist[t]
3020 3034 if idxT >= 0:
3021 3035 vStacked = numpy.vstack((volts2[idxT:,:],
3022 3036 numpy.zeros((idxT, nHeights),dtype='complex')))
@@ -3024,10 +3038,10 class SMDetection(Operation):
3024 3038 vStacked = numpy.vstack((numpy.zeros((-idxT, nHeights),dtype='complex'),
3025 3039 volts2[:(nPoints + idxT),:]))
3026 3040 voltsCCF[i,t,:] = numpy.sum((numpy.conjugate(volts1)*vStacked),axis=0)
3027
3041
3028 3042 vStacked = None
3029 3043 return voltsCCF
3030
3044
3031 3045 def __getNoise(self, power, timeSegment, timeInterval):
3032 3046 numProfPerBlock = numpy.ceil(timeSegment/timeInterval)
3033 3047 numBlocks = int(power.shape[0]/numProfPerBlock)
@@ -3036,100 +3050,100 class SMDetection(Operation):
3036 3050 listPower = numpy.array_split(power, numBlocks, 0)
3037 3051 noise = numpy.zeros((power.shape[0], power.shape[1]))
3038 3052 noise1 = numpy.zeros((power.shape[0], power.shape[1]))
3039
3053
3040 3054 startInd = 0
3041 3055 endInd = 0
3042
3056
3043 3057 for i in range(numBlocks): #split por canal
3044 3058 startInd = endInd
3045 endInd = endInd + listPower[i].shape[0]
3046
3059 endInd = endInd + listPower[i].shape[0]
3060
3047 3061 arrayBlock = listPower[i]
3048 3062 noiseAux = numpy.mean(arrayBlock, 0)
3049 3063 # noiseAux = numpy.median(noiseAux)
3050 3064 # noiseAux = numpy.mean(arrayBlock)
3051 noise[startInd:endInd,:] = noise[startInd:endInd,:] + noiseAux
3052
3065 noise[startInd:endInd,:] = noise[startInd:endInd,:] + noiseAux
3066
3053 3067 noiseAux1 = numpy.mean(arrayBlock)
3054 noise1[startInd:endInd,:] = noise1[startInd:endInd,:] + noiseAux1
3055
3068 noise1[startInd:endInd,:] = noise1[startInd:endInd,:] + noiseAux1
3069
3056 3070 return noise, noise1
3057
3071
3058 3072 def __findMeteors(self, power, thresh):
3059 3073 nProf = power.shape[0]
3060 3074 nHeights = power.shape[1]
3061 3075 listMeteors = []
3062
3076
3063 3077 for i in range(nHeights):
3064 3078 powerAux = power[:,i]
3065 3079 threshAux = thresh[:,i]
3066
3080
3067 3081 indUPthresh = numpy.where(powerAux > threshAux)[0]
3068 3082 indDNthresh = numpy.where(powerAux <= threshAux)[0]
3069
3083
3070 3084 j = 0
3071
3085
3072 3086 while (j < indUPthresh.size - 2):
3073 3087 if (indUPthresh[j + 2] == indUPthresh[j] + 2):
3074 3088 indDNAux = numpy.where(indDNthresh > indUPthresh[j])
3075 3089 indDNthresh = indDNthresh[indDNAux]
3076
3090
3077 3091 if (indDNthresh.size > 0):
3078 3092 indEnd = indDNthresh[0] - 1
3079 3093 indInit = indUPthresh[j]
3080
3094
3081 3095 meteor = powerAux[indInit:indEnd + 1]
3082 3096 indPeak = meteor.argmax() + indInit
3083 3097 FLA = sum(numpy.conj(meteor)*numpy.hstack((meteor[1:],0)))
3084
3098
3085 3099 listMeteors.append(numpy.array([i,indInit,indPeak,indEnd,FLA])) #CHEQUEAR!!!!!
3086 3100 j = numpy.where(indUPthresh == indEnd)[0] + 1
3087 3101 else: j+=1
3088 3102 else: j+=1
3089
3103
3090 3104 return listMeteors
3091
3105
3092 3106 def __removeMultipleDetections(self,listMeteors, rangeLimit, timeLimit):
3093
3094 arrayMeteors = numpy.asarray(listMeteors)
3107
3108 arrayMeteors = numpy.asarray(listMeteors)
3095 3109 listMeteors1 = []
3096
3110
3097 3111 while arrayMeteors.shape[0] > 0:
3098 3112 FLAs = arrayMeteors[:,4]
3099 3113 maxFLA = FLAs.argmax()
3100 3114 listMeteors1.append(arrayMeteors[maxFLA,:])
3101
3115
3102 3116 MeteorInitTime = arrayMeteors[maxFLA,1]
3103 3117 MeteorEndTime = arrayMeteors[maxFLA,3]
3104 3118 MeteorHeight = arrayMeteors[maxFLA,0]
3105
3119
3106 3120 #Check neighborhood
3107 3121 maxHeightIndex = MeteorHeight + rangeLimit
3108 3122 minHeightIndex = MeteorHeight - rangeLimit
3109 3123 minTimeIndex = MeteorInitTime - timeLimit
3110 3124 maxTimeIndex = MeteorEndTime + timeLimit
3111
3125
3112 3126 #Check Heights
3113 3127 indHeight = numpy.logical_and(arrayMeteors[:,0] >= minHeightIndex, arrayMeteors[:,0] <= maxHeightIndex)
3114 3128 indTime = numpy.logical_and(arrayMeteors[:,3] >= minTimeIndex, arrayMeteors[:,1] <= maxTimeIndex)
3115 3129 indBoth = numpy.where(numpy.logical_and(indTime,indHeight))
3116
3130
3117 3131 arrayMeteors = numpy.delete(arrayMeteors, indBoth, axis = 0)
3118
3132
3119 3133 return listMeteors1
3120
3134
3121 3135 def __meteorReestimation(self, listMeteors, volts, pairslist, thresh, noise, timeInterval,frequency):
3122 3136 numHeights = volts.shape[2]
3123 3137 nChannel = volts.shape[0]
3124
3138
3125 3139 thresholdPhase = thresh[0]
3126 3140 thresholdNoise = thresh[1]
3127 3141 thresholdDB = float(thresh[2])
3128
3142
3129 3143 thresholdDB1 = 10**(thresholdDB/10)
3130 3144 pairsarray = numpy.array(pairslist)
3131 3145 indSides = pairsarray[:,1]
3132
3146
3133 3147 pairslist1 = list(pairslist)
3134 3148 pairslist1.append((0,1))
3135 3149 pairslist1.append((3,4))
@@ -3138,31 +3152,31 class SMDetection(Operation):
3138 3152 listPowerSeries = []
3139 3153 listVoltageSeries = []
3140 3154 #volts has the war data
3141
3155
3142 3156 if frequency == 30e6:
3143 3157 timeLag = 45*10**-3
3144 3158 else:
3145 3159 timeLag = 15*10**-3
3146 3160 lag = numpy.ceil(timeLag/timeInterval)
3147
3161
3148 3162 for i in range(len(listMeteors)):
3149
3163
3150 3164 ###################### 3.6 - 3.7 PARAMETERS REESTIMATION #########################
3151 3165 meteorAux = numpy.zeros(16)
3152
3166
3153 3167 #Loading meteor Data (mHeight, mStart, mPeak, mEnd)
3154 3168 mHeight = listMeteors[i][0]
3155 3169 mStart = listMeteors[i][1]
3156 3170 mPeak = listMeteors[i][2]
3157 3171 mEnd = listMeteors[i][3]
3158
3172
3159 3173 #get the volt data between the start and end times of the meteor
3160 3174 meteorVolts = volts[:,mStart:mEnd+1,mHeight]
3161 3175 meteorVolts = meteorVolts.reshape(meteorVolts.shape[0], meteorVolts.shape[1], 1)
3162
3176
3163 3177 #3.6. Phase Difference estimation
3164 3178 phaseDiff, aux = self.__estimatePhaseDifference(meteorVolts, pairslist)
3165
3179
3166 3180 #3.7. Phase difference removal & meteor start, peak and end times reestimated
3167 3181 #meteorVolts0.- all Channels, all Profiles
3168 3182 meteorVolts0 = volts[:,:,mHeight]
@@ -3170,15 +3184,15 class SMDetection(Operation):
3170 3184 meteorNoise = noise[:,mHeight]
3171 3185 meteorVolts0[indSides,:] = self.__shiftPhase(meteorVolts0[indSides,:], phaseDiff) #Phase Shifting
3172 3186 powerNet0 = numpy.nansum(numpy.abs(meteorVolts0)**2, axis = 0) #Power
3173
3187
3174 3188 #Times reestimation
3175 3189 mStart1 = numpy.where(powerNet0[:mPeak] < meteorThresh[:mPeak])[0]
3176 3190 if mStart1.size > 0:
3177 3191 mStart1 = mStart1[-1] + 1
3178
3179 else:
3192
3193 else:
3180 3194 mStart1 = mPeak
3181
3195
3182 3196 mEnd1 = numpy.where(powerNet0[mPeak:] < meteorThresh[mPeak:])[0][0] + mPeak - 1
3183 3197 mEndDecayTime1 = numpy.where(powerNet0[mPeak:] < meteorNoise[mPeak:])[0]
3184 3198 if mEndDecayTime1.size == 0:
@@ -3186,7 +3200,7 class SMDetection(Operation):
3186 3200 else:
3187 3201 mEndDecayTime1 = mEndDecayTime1[0] + mPeak - 1
3188 3202 # mPeak1 = meteorVolts0[mStart1:mEnd1 + 1].argmax()
3189
3203
3190 3204 #meteorVolts1.- all Channels, from start to end
3191 3205 meteorVolts1 = meteorVolts0[:,mStart1:mEnd1 + 1]
3192 3206 meteorVolts2 = meteorVolts0[:,mPeak + lag:mEnd1 + 1]
@@ -3195,17 +3209,17 class SMDetection(Operation):
3195 3209 meteorVolts1 = meteorVolts1.reshape(meteorVolts1.shape[0], meteorVolts1.shape[1], 1)
3196 3210 meteorVolts2 = meteorVolts2.reshape(meteorVolts2.shape[0], meteorVolts2.shape[1], 1)
3197 3211 ##################### END PARAMETERS REESTIMATION #########################
3198
3212
3199 3213 ##################### 3.8 PHASE DIFFERENCE REESTIMATION ########################
3200 3214 # if mEnd1 - mStart1 > 4: #Error Number 6: echo less than 5 samples long; too short for analysis
3201 if meteorVolts2.shape[1] > 0:
3215 if meteorVolts2.shape[1] > 0:
3202 3216 #Phase Difference re-estimation
3203 3217 phaseDiff1, phaseDiffint = self.__estimatePhaseDifference(meteorVolts2, pairslist1) #Phase Difference Estimation
3204 3218 # phaseDiff1, phaseDiffint = self.estimatePhaseDifference(meteorVolts2, pairslist)
3205 3219 meteorVolts2 = meteorVolts2.reshape(meteorVolts2.shape[0], meteorVolts2.shape[1])
3206 3220 phaseDiff11 = numpy.reshape(phaseDiff1, (phaseDiff1.shape[0],1))
3207 3221 meteorVolts2[indSides,:] = self.__shiftPhase(meteorVolts2[indSides,:], phaseDiff11[0:4]) #Phase Shifting
3208
3222
3209 3223 #Phase Difference RMS
3210 3224 phaseRMS1 = numpy.sqrt(numpy.mean(numpy.square(phaseDiff1)))
3211 3225 powerNet1 = numpy.nansum(numpy.abs(meteorVolts1[:,:])**2,0)
@@ -3220,27 +3234,27 class SMDetection(Operation):
3220 3234 #Vectorize
3221 3235 meteorAux[0:7] = [mHeight, mStart1, mPeak1, mEnd1, mPeakPower1, mSNR1, phaseRMS1]
3222 3236 meteorAux[7:11] = phaseDiffint[0:4]
3223
3237
3224 3238 #Rejection Criterions
3225 3239 if phaseRMS1 > thresholdPhase: #Error Number 17: Phase variation
3226 3240 meteorAux[-1] = 17
3227 3241 elif mSNR1 < thresholdDB1: #Error Number 1: SNR < threshold dB
3228 3242 meteorAux[-1] = 1
3229
3230
3231 else:
3243
3244
3245 else:
3232 3246 meteorAux[0:4] = [mHeight, mStart, mPeak, mEnd]
3233 3247 meteorAux[-1] = 6 #Error Number 6: echo less than 5 samples long; too short for analysis
3234 3248 PowerSeries = 0
3235
3249
3236 3250 listMeteors1.append(meteorAux)
3237 3251 listPowerSeries.append(PowerSeries)
3238 3252 listVoltageSeries.append(meteorVolts1)
3239
3240 return listMeteors1, listPowerSeries, listVoltageSeries
3241
3253
3254 return listMeteors1, listPowerSeries, listVoltageSeries
3255
3242 3256 def __estimateDecayTime(self, listMeteors, listPower, timeInterval, frequency):
3243
3257
3244 3258 threshError = 10
3245 3259 #Depending if it is 30 or 50 MHz
3246 3260 if frequency == 30e6:
@@ -3248,22 +3262,22 class SMDetection(Operation):
3248 3262 else:
3249 3263 timeLag = 15*10**-3
3250 3264 lag = numpy.ceil(timeLag/timeInterval)
3251
3265
3252 3266 listMeteors1 = []
3253
3267
3254 3268 for i in range(len(listMeteors)):
3255 3269 meteorPower = listPower[i]
3256 3270 meteorAux = listMeteors[i]
3257
3271
3258 3272 if meteorAux[-1] == 0:
3259 3273
3260 try:
3274 try:
3261 3275 indmax = meteorPower.argmax()
3262 3276 indlag = indmax + lag
3263
3277
3264 3278 y = meteorPower[indlag:]
3265 3279 x = numpy.arange(0, y.size)*timeLag
3266
3280
3267 3281 #first guess
3268 3282 a = y[0]
3269 3283 tau = timeLag
@@ -3272,26 +3286,26 class SMDetection(Operation):
3272 3286 y1 = self.__exponential_function(x, *popt)
3273 3287 #error estimation
3274 3288 error = sum((y - y1)**2)/(numpy.var(y)*(y.size - popt.size))
3275
3289
3276 3290 decayTime = popt[1]
3277 3291 riseTime = indmax*timeInterval
3278 3292 meteorAux[11:13] = [decayTime, error]
3279
3293
3280 3294 #Table items 7, 8 and 11
3281 3295 if (riseTime > 0.3): #Number 7: Echo rise exceeds 0.3s
3282 meteorAux[-1] = 7
3296 meteorAux[-1] = 7
3283 3297 elif (decayTime < 2*riseTime) : #Number 8: Echo decay time less than than twice rise time
3284 3298 meteorAux[-1] = 8
3285 3299 if (error > threshError): #Number 11: Poor fit to amplitude for estimation of decay time
3286 meteorAux[-1] = 11
3287
3288
3300 meteorAux[-1] = 11
3301
3302
3289 3303 except:
3290 meteorAux[-1] = 11
3291
3292
3304 meteorAux[-1] = 11
3305
3306
3293 3307 listMeteors1.append(meteorAux)
3294
3308
3295 3309 return listMeteors1
3296 3310
3297 3311 #Exponential Function
@@ -3299,9 +3313,9 class SMDetection(Operation):
3299 3313 def __exponential_function(self, x, a, tau):
3300 3314 y = a*numpy.exp(-x/tau)
3301 3315 return y
3302
3316
3303 3317 def __getRadialVelocity(self, listMeteors, listVolts, radialStdThresh, pairslist, timeInterval):
3304
3318
3305 3319 pairslist1 = list(pairslist)
3306 3320 pairslist1.append((0,1))
3307 3321 pairslist1.append((3,4))
@@ -3311,33 +3325,33 class SMDetection(Operation):
3311 3325 c = 3e8
3312 3326 lag = numpy.ceil(timeLag/timeInterval)
3313 3327 freq = 30e6
3314
3328
3315 3329 listMeteors1 = []
3316
3330
3317 3331 for i in range(len(listMeteors)):
3318 3332 meteorAux = listMeteors[i]
3319 3333 if meteorAux[-1] == 0:
3320 3334 mStart = listMeteors[i][1]
3321 mPeak = listMeteors[i][2]
3335 mPeak = listMeteors[i][2]
3322 3336 mLag = mPeak - mStart + lag
3323
3337
3324 3338 #get the volt data between the start and end times of the meteor
3325 3339 meteorVolts = listVolts[i]
3326 3340 meteorVolts = meteorVolts.reshape(meteorVolts.shape[0], meteorVolts.shape[1], 1)
3327 3341
3328 3342 #Get CCF
3329 3343 allCCFs = self.__calculateCCF(meteorVolts, pairslist1, [-2,-1,0,1,2])
3330
3344
3331 3345 #Method 2
3332 3346 slopes = numpy.zeros(numPairs)
3333 3347 time = numpy.array([-2,-1,1,2])*timeInterval
3334 3348 angAllCCF = numpy.angle(allCCFs[:,[0,1,3,4],0])
3335
3349
3336 3350 #Correct phases
3337 3351 derPhaseCCF = angAllCCF[:,1:] - angAllCCF[:,0:-1]
3338 3352 indDer = numpy.where(numpy.abs(derPhaseCCF) > numpy.pi)
3339
3340 if indDer[0].shape[0] > 0:
3353
3354 if indDer[0].shape[0] > 0:
3341 3355 for i in range(indDer[0].shape[0]):
3342 3356 signo = -numpy.sign(derPhaseCCF[indDer[0][i],indDer[1][i]])
3343 3357 angAllCCF[indDer[0][i],indDer[1][i]+1:] += signo*2*numpy.pi
@@ -3346,51 +3360,51 class SMDetection(Operation):
3346 3360 for j in range(numPairs):
3347 3361 fit = stats.linregress(time, angAllCCF[j,:])
3348 3362 slopes[j] = fit[0]
3349
3363
3350 3364 #Remove Outlier
3351 3365 # indOut = numpy.argmax(numpy.abs(slopes - numpy.mean(slopes)))
3352 3366 # slopes = numpy.delete(slopes,indOut)
3353 3367 # indOut = numpy.argmax(numpy.abs(slopes - numpy.mean(slopes)))
3354 3368 # slopes = numpy.delete(slopes,indOut)
3355
3369
3356 3370 radialVelocity = -numpy.mean(slopes)*(0.25/numpy.pi)*(c/freq)
3357 3371 radialError = numpy.std(slopes)*(0.25/numpy.pi)*(c/freq)
3358 3372 meteorAux[-2] = radialError
3359 3373 meteorAux[-3] = radialVelocity
3360
3374
3361 3375 #Setting Error
3362 3376 #Number 15: Radial Drift velocity or projected horizontal velocity exceeds 200 m/s
3363 if numpy.abs(radialVelocity) > 200:
3377 if numpy.abs(radialVelocity) > 200:
3364 3378 meteorAux[-1] = 15
3365 3379 #Number 12: Poor fit to CCF variation for estimation of radial drift velocity
3366 3380 elif radialError > radialStdThresh:
3367 3381 meteorAux[-1] = 12
3368
3382
3369 3383 listMeteors1.append(meteorAux)
3370 3384 return listMeteors1
3371
3385
3372 3386 def __setNewArrays(self, listMeteors, date, heiRang):
3373
3387
3374 3388 #New arrays
3375 3389 arrayMeteors = numpy.array(listMeteors)
3376 3390 arrayParameters = numpy.zeros((len(listMeteors), 13))
3377
3391
3378 3392 #Date inclusion
3379 3393 # date = re.findall(r'\((.*?)\)', date)
3380 3394 # date = date[0].split(',')
3381 3395 # date = map(int, date)
3382 #
3396 #
3383 3397 # if len(date)<6:
3384 3398 # date.append(0)
3385 #
3399 #
3386 3400 # date = [date[0]*10000 + date[1]*100 + date[2], date[3]*10000 + date[4]*100 + date[5]]
3387 3401 # arrayDate = numpy.tile(date, (len(listMeteors), 1))
3388 3402 arrayDate = numpy.tile(date, (len(listMeteors)))
3389
3403
3390 3404 #Meteor array
3391 3405 # arrayMeteors[:,0] = heiRang[arrayMeteors[:,0].astype(int)]
3392 3406 # arrayMeteors = numpy.hstack((arrayDate, arrayMeteors))
3393
3407
3394 3408 #Parameters Array
3395 3409 arrayParameters[:,0] = arrayDate #Date
3396 3410 arrayParameters[:,1] = heiRang[arrayMeteors[:,0].astype(int)] #Range
@@ -3398,13 +3412,13 class SMDetection(Operation):
3398 3412 arrayParameters[:,8:12] = arrayMeteors[:,7:11] #Phases
3399 3413 arrayParameters[:,-1] = arrayMeteors[:,-1] #Error
3400 3414
3401
3415
3402 3416 return arrayParameters
3403
3417
3404 3418 class CorrectSMPhases(Operation):
3405
3419
3406 3420 def run(self, dataOut, phaseOffsets, hmin = 50, hmax = 150, azimuth = 45, channelPositions = None):
3407
3421
3408 3422 arrayParameters = dataOut.data_param
3409 3423 pairsList = []
3410 3424 pairx = (0,1)
@@ -3412,49 +3426,49 class CorrectSMPhases(Operation):
3412 3426 pairsList.append(pairx)
3413 3427 pairsList.append(pairy)
3414 3428 jph = numpy.zeros(4)
3415
3429
3416 3430 phaseOffsets = numpy.array(phaseOffsets)*numpy.pi/180
3417 3431 # arrayParameters[:,8:12] = numpy.unwrap(arrayParameters[:,8:12] + phaseOffsets)
3418 3432 arrayParameters[:,8:12] = numpy.angle(numpy.exp(1j*(arrayParameters[:,8:12] + phaseOffsets)))
3419
3433
3420 3434 meteorOps = SMOperations()
3421 3435 if channelPositions is None:
3422 3436 # channelPositions = [(2.5,0), (0,2.5), (0,0), (0,4.5), (-2,0)] #T
3423 3437 channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)] #Estrella
3424
3438
3425 3439 pairslist0, distances = meteorOps.getPhasePairs(channelPositions)
3426 3440 h = (hmin,hmax)
3427
3441
3428 3442 arrayParameters = meteorOps.getMeteorParams(arrayParameters, azimuth, h, pairsList, distances, jph)
3429
3443
3430 3444 dataOut.data_param = arrayParameters
3431 3445 return
3432 3446
3433 3447 class SMPhaseCalibration(Operation):
3434
3448
3435 3449 __buffer = None
3436 3450
3437 3451 __initime = None
3438 3452
3439 3453 __dataReady = False
3440
3454
3441 3455 __isConfig = False
3442
3456
3443 3457 def __checkTime(self, currentTime, initTime, paramInterval, outputInterval):
3444
3458
3445 3459 dataTime = currentTime + paramInterval
3446 3460 deltaTime = dataTime - initTime
3447
3461
3448 3462 if deltaTime >= outputInterval or deltaTime < 0:
3449 3463 return True
3450
3464
3451 3465 return False
3452
3466
3453 3467 def __getGammas(self, pairs, d, phases):
3454 3468 gammas = numpy.zeros(2)
3455
3469
3456 3470 for i in range(len(pairs)):
3457
3471
3458 3472 pairi = pairs[i]
3459 3473
3460 3474 phip3 = phases[:,pairi[0]]
@@ -3468,7 +3482,7 class SMPhaseCalibration(Operation):
3468 3482 jgamma = numpy.angle(numpy.exp(1j*jgamma))
3469 3483 # jgamma[jgamma>numpy.pi] -= 2*numpy.pi
3470 3484 # jgamma[jgamma<-numpy.pi] += 2*numpy.pi
3471
3485
3472 3486 #Revised distribution
3473 3487 jgammaArray = numpy.hstack((jgamma,jgamma+0.5*numpy.pi,jgamma-0.5*numpy.pi))
3474 3488
@@ -3477,39 +3491,39 class SMPhaseCalibration(Operation):
3477 3491 rmin = -0.5*numpy.pi
3478 3492 rmax = 0.5*numpy.pi
3479 3493 phaseHisto = numpy.histogram(jgammaArray, bins=nBins, range=(rmin,rmax))
3480
3494
3481 3495 meteorsY = phaseHisto[0]
3482 3496 phasesX = phaseHisto[1][:-1]
3483 3497 width = phasesX[1] - phasesX[0]
3484 3498 phasesX += width/2
3485
3499
3486 3500 #Gaussian aproximation
3487 3501 bpeak = meteorsY.argmax()
3488 3502 peak = meteorsY.max()
3489 3503 jmin = bpeak - 5
3490 3504 jmax = bpeak + 5 + 1
3491
3505
3492 3506 if jmin<0:
3493 3507 jmin = 0
3494 3508 jmax = 6
3495 3509 elif jmax > meteorsY.size:
3496 3510 jmin = meteorsY.size - 6
3497 3511 jmax = meteorsY.size
3498
3512
3499 3513 x0 = numpy.array([peak,bpeak,50])
3500 3514 coeff = optimize.leastsq(self.__residualFunction, x0, args=(meteorsY[jmin:jmax], phasesX[jmin:jmax]))
3501
3515
3502 3516 #Gammas
3503 3517 gammas[i] = coeff[0][1]
3504
3518
3505 3519 return gammas
3506
3520
3507 3521 def __residualFunction(self, coeffs, y, t):
3508
3522
3509 3523 return y - self.__gauss_function(t, coeffs)
3510 3524
3511 3525 def __gauss_function(self, t, coeffs):
3512
3526
3513 3527 return coeffs[0]*numpy.exp(-0.5*((t - coeffs[1]) / coeffs[2])**2)
3514 3528
3515 3529 def __getPhases(self, azimuth, h, pairsList, d, gammas, meteorsArray):
@@ -3530,16 +3544,16 class SMPhaseCalibration(Operation):
3530 3544 max_xangle = range_angle[iz]/2 + center_xangle
3531 3545 min_yangle = -range_angle[iz]/2 + center_yangle
3532 3546 max_yangle = range_angle[iz]/2 + center_yangle
3533
3547
3534 3548 inc_x = (max_xangle-min_xangle)/nstepsx
3535 3549 inc_y = (max_yangle-min_yangle)/nstepsy
3536
3550
3537 3551 alpha_y = numpy.arange(nstepsy)*inc_y + min_yangle
3538 3552 alpha_x = numpy.arange(nstepsx)*inc_x + min_xangle
3539 3553 penalty = numpy.zeros((nstepsx,nstepsy))
3540 3554 jph_array = numpy.zeros((nchan,nstepsx,nstepsy))
3541 3555 jph = numpy.zeros(nchan)
3542
3556
3543 3557 # Iterations looking for the offset
3544 3558 for iy in range(int(nstepsy)):
3545 3559 for ix in range(int(nstepsx)):
@@ -3547,46 +3561,46 class SMPhaseCalibration(Operation):
3547 3561 d2 = d[pairsList[1][1]]
3548 3562 d5 = d[pairsList[0][0]]
3549 3563 d4 = d[pairsList[0][1]]
3550
3564
3551 3565 alp2 = alpha_y[iy] #gamma 1
3552 alp4 = alpha_x[ix] #gamma 0
3553
3566 alp4 = alpha_x[ix] #gamma 0
3567
3554 3568 alp3 = -alp2*d3/d2 - gammas[1]
3555 3569 alp5 = -alp4*d5/d4 - gammas[0]
3556 3570 # jph[pairy[1]] = alpha_y[iy]
3557 # jph[pairy[0]] = -gammas[1] - alpha_y[iy]*d[pairy[1]]/d[pairy[0]]
3558
3571 # jph[pairy[0]] = -gammas[1] - alpha_y[iy]*d[pairy[1]]/d[pairy[0]]
3572
3559 3573 # jph[pairx[1]] = alpha_x[ix]
3560 3574 # jph[pairx[0]] = -gammas[0] - alpha_x[ix]*d[pairx[1]]/d[pairx[0]]
3561 3575 jph[pairsList[0][1]] = alp4
3562 3576 jph[pairsList[0][0]] = alp5
3563 3577 jph[pairsList[1][0]] = alp3
3564 jph[pairsList[1][1]] = alp2
3578 jph[pairsList[1][1]] = alp2
3565 3579 jph_array[:,ix,iy] = jph
3566 3580 # d = [2.0,2.5,2.5,2.0]
3567 #falta chequear si va a leer bien los meteoros
3581 #falta chequear si va a leer bien los meteoros
3568 3582 meteorsArray1 = meteorOps.getMeteorParams(meteorsArray, azimuth, h, pairsList, d, jph)
3569 3583 error = meteorsArray1[:,-1]
3570 3584 ind1 = numpy.where(error==0)[0]
3571 3585 penalty[ix,iy] = ind1.size
3572
3586
3573 3587 i,j = numpy.unravel_index(penalty.argmax(), penalty.shape)
3574 3588 phOffset = jph_array[:,i,j]
3575
3589
3576 3590 center_xangle = phOffset[pairx[1]]
3577 3591 center_yangle = phOffset[pairy[1]]
3578
3592
3579 3593 phOffset = numpy.angle(numpy.exp(1j*jph_array[:,i,j]))
3580 phOffset = phOffset*180/numpy.pi
3594 phOffset = phOffset*180/numpy.pi
3581 3595 return phOffset
3582
3583
3596
3597
3584 3598 def run(self, dataOut, hmin, hmax, channelPositions=None, nHours = 1):
3585
3599
3586 3600 dataOut.flagNoData = True
3587 self.__dataReady = False
3601 self.__dataReady = False
3588 3602 dataOut.outputInterval = nHours*3600
3589
3603
3590 3604 if self.__isConfig == False:
3591 3605 # self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
3592 3606 #Get Initial LTC time
@@ -3594,19 +3608,19 class SMPhaseCalibration(Operation):
3594 3608 self.__initime = (self.__initime.replace(minute = 0, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
3595 3609
3596 3610 self.__isConfig = True
3597
3611
3598 3612 if self.__buffer is None:
3599 3613 self.__buffer = dataOut.data_param.copy()
3600 3614
3601 3615 else:
3602 3616 self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
3603
3617
3604 3618 self.__dataReady = self.__checkTime(dataOut.utctime, self.__initime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
3605
3619
3606 3620 if self.__dataReady:
3607 3621 dataOut.utctimeInit = self.__initime
3608 3622 self.__initime += dataOut.outputInterval #to erase time offset
3609
3623
3610 3624 freq = dataOut.frequency
3611 3625 c = dataOut.C #m/s
3612 3626 lamb = c/freq
@@ -3628,13 +3642,13 class SMPhaseCalibration(Operation):
3628 3642 pairs.append((1,0))
3629 3643 else:
3630 3644 pairs.append((0,1))
3631
3645
3632 3646 if distances[3] > distances[2]:
3633 3647 pairs.append((3,2))
3634 3648 else:
3635 3649 pairs.append((2,3))
3636 3650 # distances1 = [-distances[0]*lamb, distances[1]*lamb, -distances[2]*lamb, distances[3]*lamb]
3637
3651
3638 3652 meteorsArray = self.__buffer
3639 3653 error = meteorsArray[:,-1]
3640 3654 boolError = (error==0)|(error==3)|(error==4)|(error==13)|(error==14)
@@ -3642,7 +3656,7 class SMPhaseCalibration(Operation):
3642 3656 meteorsArray = meteorsArray[ind1,:]
3643 3657 meteorsArray[:,-1] = 0
3644 3658 phases = meteorsArray[:,8:12]
3645
3659
3646 3660 #Calculate Gammas
3647 3661 gammas = self.__getGammas(pairs, distances, phases)
3648 3662 # gammas = numpy.array([-21.70409463,45.76935864])*numpy.pi/180
@@ -3652,22 +3666,22 class SMPhaseCalibration(Operation):
3652 3666 dataOut.data_output = -phasesOff
3653 3667 dataOut.flagNoData = False
3654 3668 self.__buffer = None
3655
3656
3669
3670
3657 3671 return
3658
3672
3659 3673 class SMOperations():
3660
3674
3661 3675 def __init__(self):
3662
3676
3663 3677 return
3664
3678
3665 3679 def getMeteorParams(self, arrayParameters0, azimuth, h, pairsList, distances, jph):
3666
3680
3667 3681 arrayParameters = arrayParameters0.copy()
3668 3682 hmin = h[0]
3669 3683 hmax = h[1]
3670
3684
3671 3685 #Calculate AOA (Error N 3, 4)
3672 3686 #JONES ET AL. 1998
3673 3687 AOAthresh = numpy.pi/8
@@ -3675,72 +3689,72 class SMOperations():
3675 3689 phases = -arrayParameters[:,8:12] + jph
3676 3690 # phases = numpy.unwrap(phases)
3677 3691 arrayParameters[:,3:6], arrayParameters[:,-1] = self.__getAOA(phases, pairsList, distances, error, AOAthresh, azimuth)
3678
3692
3679 3693 #Calculate Heights (Error N 13 and 14)
3680 3694 error = arrayParameters[:,-1]
3681 3695 Ranges = arrayParameters[:,1]
3682 3696 zenith = arrayParameters[:,4]
3683 3697 arrayParameters[:,2], arrayParameters[:,-1] = self.__getHeights(Ranges, zenith, error, hmin, hmax)
3684
3698
3685 3699 #----------------------- Get Final data ------------------------------------
3686 3700 # error = arrayParameters[:,-1]
3687 3701 # ind1 = numpy.where(error==0)[0]
3688 3702 # arrayParameters = arrayParameters[ind1,:]
3689
3703
3690 3704 return arrayParameters
3691
3705
3692 3706 def __getAOA(self, phases, pairsList, directions, error, AOAthresh, azimuth):
3693
3707
3694 3708 arrayAOA = numpy.zeros((phases.shape[0],3))
3695 3709 cosdir0, cosdir = self.__getDirectionCosines(phases, pairsList,directions)
3696
3710
3697 3711 arrayAOA[:,:2] = self.__calculateAOA(cosdir, azimuth)
3698 3712 cosDirError = numpy.sum(numpy.abs(cosdir0 - cosdir), axis = 1)
3699 3713 arrayAOA[:,2] = cosDirError
3700
3714
3701 3715 azimuthAngle = arrayAOA[:,0]
3702 3716 zenithAngle = arrayAOA[:,1]
3703
3717
3704 3718 #Setting Error
3705 3719 indError = numpy.where(numpy.logical_or(error == 3, error == 4))[0]
3706 3720 error[indError] = 0
3707 3721 #Number 3: AOA not fesible
3708 3722 indInvalid = numpy.where(numpy.logical_and((numpy.logical_or(numpy.isnan(zenithAngle), numpy.isnan(azimuthAngle))),error == 0))[0]
3709 error[indInvalid] = 3
3723 error[indInvalid] = 3
3710 3724 #Number 4: Large difference in AOAs obtained from different antenna baselines
3711 3725 indInvalid = numpy.where(numpy.logical_and(cosDirError > AOAthresh,error == 0))[0]
3712 error[indInvalid] = 4
3726 error[indInvalid] = 4
3713 3727 return arrayAOA, error
3714
3728
3715 3729 def __getDirectionCosines(self, arrayPhase, pairsList, distances):
3716
3730
3717 3731 #Initializing some variables
3718 3732 ang_aux = numpy.array([-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8])*2*numpy.pi
3719 3733 ang_aux = ang_aux.reshape(1,ang_aux.size)
3720
3734
3721 3735 cosdir = numpy.zeros((arrayPhase.shape[0],2))
3722 3736 cosdir0 = numpy.zeros((arrayPhase.shape[0],2))
3723
3724
3737
3738
3725 3739 for i in range(2):
3726 3740 ph0 = arrayPhase[:,pairsList[i][0]]
3727 3741 ph1 = arrayPhase[:,pairsList[i][1]]
3728 3742 d0 = distances[pairsList[i][0]]
3729 3743 d1 = distances[pairsList[i][1]]
3730
3731 ph0_aux = ph0 + ph1
3744
3745 ph0_aux = ph0 + ph1
3732 3746 ph0_aux = numpy.angle(numpy.exp(1j*ph0_aux))
3733 3747 # ph0_aux[ph0_aux > numpy.pi] -= 2*numpy.pi
3734 # ph0_aux[ph0_aux < -numpy.pi] += 2*numpy.pi
3748 # ph0_aux[ph0_aux < -numpy.pi] += 2*numpy.pi
3735 3749 #First Estimation
3736 3750 cosdir0[:,i] = (ph0_aux)/(2*numpy.pi*(d0 - d1))
3737
3751
3738 3752 #Most-Accurate Second Estimation
3739 3753 phi1_aux = ph0 - ph1
3740 3754 phi1_aux = phi1_aux.reshape(phi1_aux.size,1)
3741 3755 #Direction Cosine 1
3742 3756 cosdir1 = (phi1_aux + ang_aux)/(2*numpy.pi*(d0 + d1))
3743
3757
3744 3758 #Searching the correct Direction Cosine
3745 3759 cosdir0_aux = cosdir0[:,i]
3746 3760 cosdir0_aux = cosdir0_aux.reshape(cosdir0_aux.size,1)
@@ -3749,59 +3763,59 class SMOperations():
3749 3763 indcos = cosDiff.argmin(axis = 1)
3750 3764 #Saving Value obtained
3751 3765 cosdir[:,i] = cosdir1[numpy.arange(len(indcos)),indcos]
3752
3766
3753 3767 return cosdir0, cosdir
3754
3768
3755 3769 def __calculateAOA(self, cosdir, azimuth):
3756 3770 cosdirX = cosdir[:,0]
3757 3771 cosdirY = cosdir[:,1]
3758
3772
3759 3773 zenithAngle = numpy.arccos(numpy.sqrt(1 - cosdirX**2 - cosdirY**2))*180/numpy.pi
3760 3774 azimuthAngle = numpy.arctan2(cosdirX,cosdirY)*180/numpy.pi + azimuth#0 deg north, 90 deg east
3761 3775 angles = numpy.vstack((azimuthAngle, zenithAngle)).transpose()
3762
3776
3763 3777 return angles
3764
3778
3765 3779 def __getHeights(self, Ranges, zenith, error, minHeight, maxHeight):
3766
3780
3767 3781 Ramb = 375 #Ramb = c/(2*PRF)
3768 3782 Re = 6371 #Earth Radius
3769 3783 heights = numpy.zeros(Ranges.shape)
3770
3784
3771 3785 R_aux = numpy.array([0,1,2])*Ramb
3772 3786 R_aux = R_aux.reshape(1,R_aux.size)
3773 3787
3774 3788 Ranges = Ranges.reshape(Ranges.size,1)
3775
3789
3776 3790 Ri = Ranges + R_aux
3777 3791 hi = numpy.sqrt(Re**2 + Ri**2 + (2*Re*numpy.cos(zenith*numpy.pi/180)*Ri.transpose()).transpose()) - Re
3778
3792
3779 3793 #Check if there is a height between 70 and 110 km
3780 3794 h_bool = numpy.sum(numpy.logical_and(hi > minHeight, hi < maxHeight), axis = 1)
3781 3795 ind_h = numpy.where(h_bool == 1)[0]
3782
3796
3783 3797 hCorr = hi[ind_h, :]
3784 3798 ind_hCorr = numpy.where(numpy.logical_and(hi > minHeight, hi < maxHeight))
3785
3799
3786 3800 hCorr = hi[ind_hCorr][:len(ind_h)]
3787 3801 heights[ind_h] = hCorr
3788
3802
3789 3803 #Setting Error
3790 3804 #Number 13: Height unresolvable echo: not valid height within 70 to 110 km
3791 #Number 14: Height ambiguous echo: more than one possible height within 70 to 110 km
3805 #Number 14: Height ambiguous echo: more than one possible height within 70 to 110 km
3792 3806 indError = numpy.where(numpy.logical_or(error == 13, error == 14))[0]
3793 3807 error[indError] = 0
3794 indInvalid2 = numpy.where(numpy.logical_and(h_bool > 1, error == 0))[0]
3808 indInvalid2 = numpy.where(numpy.logical_and(h_bool > 1, error == 0))[0]
3795 3809 error[indInvalid2] = 14
3796 3810 indInvalid1 = numpy.where(numpy.logical_and(h_bool == 0, error == 0))[0]
3797 error[indInvalid1] = 13
3798
3811 error[indInvalid1] = 13
3812
3799 3813 return heights, error
3800
3814
3801 3815 def getPhasePairs(self, channelPositions):
3802 3816 chanPos = numpy.array(channelPositions)
3803 3817 listOper = list(itertools.combinations(list(range(5)),2))
3804
3818
3805 3819 distances = numpy.zeros(4)
3806 3820 axisX = []
3807 3821 axisY = []
@@ -3809,15 +3823,15 class SMOperations():
3809 3823 distY = numpy.zeros(3)
3810 3824 ix = 0
3811 3825 iy = 0
3812
3826
3813 3827 pairX = numpy.zeros((2,2))
3814 3828 pairY = numpy.zeros((2,2))
3815
3829
3816 3830 for i in range(len(listOper)):
3817 3831 pairi = listOper[i]
3818
3832
3819 3833 posDif = numpy.abs(chanPos[pairi[0],:] - chanPos[pairi[1],:])
3820
3834
3821 3835 if posDif[0] == 0:
3822 3836 axisY.append(pairi)
3823 3837 distY[iy] = posDif[1]
@@ -3826,7 +3840,7 class SMOperations():
3826 3840 axisX.append(pairi)
3827 3841 distX[ix] = posDif[0]
3828 3842 ix += 1
3829
3843
3830 3844 for i in range(2):
3831 3845 if i==0:
3832 3846 dist0 = distX
@@ -3834,7 +3848,7 class SMOperations():
3834 3848 else:
3835 3849 dist0 = distY
3836 3850 axis0 = axisY
3837
3851
3838 3852 side = numpy.argsort(dist0)[:-1]
3839 3853 axis0 = numpy.array(axis0)[side,:]
3840 3854 chanC = int(numpy.intersect1d(axis0[0,:], axis0[1,:])[0])
@@ -3842,7 +3856,7 class SMOperations():
3842 3856 side = axis1[axis1 != chanC]
3843 3857 diff1 = chanPos[chanC,i] - chanPos[side[0],i]
3844 3858 diff2 = chanPos[chanC,i] - chanPos[side[1],i]
3845 if diff1<0:
3859 if diff1<0:
3846 3860 chan2 = side[0]
3847 3861 d2 = numpy.abs(diff1)
3848 3862 chan1 = side[1]
@@ -3852,7 +3866,7 class SMOperations():
3852 3866 d2 = numpy.abs(diff2)
3853 3867 chan1 = side[0]
3854 3868 d1 = numpy.abs(diff1)
3855
3869
3856 3870 if i==0:
3857 3871 chanCX = chanC
3858 3872 chan1X = chan1
@@ -3864,10 +3878,10 class SMOperations():
3864 3878 chan2Y = chan2
3865 3879 distances[2:4] = numpy.array([d1,d2])
3866 3880 # axisXsides = numpy.reshape(axisX[ix,:],4)
3867 #
3881 #
3868 3882 # channelCentX = int(numpy.intersect1d(pairX[0,:], pairX[1,:])[0])
3869 3883 # channelCentY = int(numpy.intersect1d(pairY[0,:], pairY[1,:])[0])
3870 #
3884 #
3871 3885 # ind25X = numpy.where(pairX[0,:] != channelCentX)[0][0]
3872 3886 # ind20X = numpy.where(pairX[1,:] != channelCentX)[0][0]
3873 3887 # channel25X = int(pairX[0,ind25X])
@@ -3876,59 +3890,59 class SMOperations():
3876 3890 # ind20Y = numpy.where(pairY[1,:] != channelCentY)[0][0]
3877 3891 # channel25Y = int(pairY[0,ind25Y])
3878 3892 # channel20Y = int(pairY[1,ind20Y])
3879
3893
3880 3894 # pairslist = [(channelCentX, channel25X),(channelCentX, channel20X),(channelCentY,channel25Y),(channelCentY, channel20Y)]
3881 pairslist = [(chanCX, chan1X),(chanCX, chan2X),(chanCY,chan1Y),(chanCY, chan2Y)]
3882
3895 pairslist = [(chanCX, chan1X),(chanCX, chan2X),(chanCY,chan1Y),(chanCY, chan2Y)]
3896
3883 3897 return pairslist, distances
3884 3898 # def __getAOA(self, phases, pairsList, error, AOAthresh, azimuth):
3885 #
3899 #
3886 3900 # arrayAOA = numpy.zeros((phases.shape[0],3))
3887 3901 # cosdir0, cosdir = self.__getDirectionCosines(phases, pairsList)
3888 #
3902 #
3889 3903 # arrayAOA[:,:2] = self.__calculateAOA(cosdir, azimuth)
3890 3904 # cosDirError = numpy.sum(numpy.abs(cosdir0 - cosdir), axis = 1)
3891 3905 # arrayAOA[:,2] = cosDirError
3892 #
3906 #
3893 3907 # azimuthAngle = arrayAOA[:,0]
3894 3908 # zenithAngle = arrayAOA[:,1]
3895 #
3909 #
3896 3910 # #Setting Error
3897 3911 # #Number 3: AOA not fesible
3898 3912 # indInvalid = numpy.where(numpy.logical_and((numpy.logical_or(numpy.isnan(zenithAngle), numpy.isnan(azimuthAngle))),error == 0))[0]
3899 # error[indInvalid] = 3
3913 # error[indInvalid] = 3
3900 3914 # #Number 4: Large difference in AOAs obtained from different antenna baselines
3901 3915 # indInvalid = numpy.where(numpy.logical_and(cosDirError > AOAthresh,error == 0))[0]
3902 # error[indInvalid] = 4
3916 # error[indInvalid] = 4
3903 3917 # return arrayAOA, error
3904 #
3918 #
3905 3919 # def __getDirectionCosines(self, arrayPhase, pairsList):
3906 #
3920 #
3907 3921 # #Initializing some variables
3908 3922 # ang_aux = numpy.array([-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8])*2*numpy.pi
3909 3923 # ang_aux = ang_aux.reshape(1,ang_aux.size)
3910 #
3924 #
3911 3925 # cosdir = numpy.zeros((arrayPhase.shape[0],2))
3912 3926 # cosdir0 = numpy.zeros((arrayPhase.shape[0],2))
3913 #
3914 #
3927 #
3928 #
3915 3929 # for i in range(2):
3916 3930 # #First Estimation
3917 3931 # phi0_aux = arrayPhase[:,pairsList[i][0]] + arrayPhase[:,pairsList[i][1]]
3918 3932 # #Dealias
3919 3933 # indcsi = numpy.where(phi0_aux > numpy.pi)
3920 # phi0_aux[indcsi] -= 2*numpy.pi
3934 # phi0_aux[indcsi] -= 2*numpy.pi
3921 3935 # indcsi = numpy.where(phi0_aux < -numpy.pi)
3922 # phi0_aux[indcsi] += 2*numpy.pi
3936 # phi0_aux[indcsi] += 2*numpy.pi
3923 3937 # #Direction Cosine 0
3924 3938 # cosdir0[:,i] = -(phi0_aux)/(2*numpy.pi*0.5)
3925 #
3939 #
3926 3940 # #Most-Accurate Second Estimation
3927 3941 # phi1_aux = arrayPhase[:,pairsList[i][0]] - arrayPhase[:,pairsList[i][1]]
3928 3942 # phi1_aux = phi1_aux.reshape(phi1_aux.size,1)
3929 3943 # #Direction Cosine 1
3930 3944 # cosdir1 = -(phi1_aux + ang_aux)/(2*numpy.pi*4.5)
3931 #
3945 #
3932 3946 # #Searching the correct Direction Cosine
3933 3947 # cosdir0_aux = cosdir0[:,i]
3934 3948 # cosdir0_aux = cosdir0_aux.reshape(cosdir0_aux.size,1)
@@ -3937,51 +3951,50 class SMOperations():
3937 3951 # indcos = cosDiff.argmin(axis = 1)
3938 3952 # #Saving Value obtained
3939 3953 # cosdir[:,i] = cosdir1[numpy.arange(len(indcos)),indcos]
3940 #
3954 #
3941 3955 # return cosdir0, cosdir
3942 #
3956 #
3943 3957 # def __calculateAOA(self, cosdir, azimuth):
3944 3958 # cosdirX = cosdir[:,0]
3945 3959 # cosdirY = cosdir[:,1]
3946 #
3960 #
3947 3961 # zenithAngle = numpy.arccos(numpy.sqrt(1 - cosdirX**2 - cosdirY**2))*180/numpy.pi
3948 3962 # azimuthAngle = numpy.arctan2(cosdirX,cosdirY)*180/numpy.pi + azimuth #0 deg north, 90 deg east
3949 3963 # angles = numpy.vstack((azimuthAngle, zenithAngle)).transpose()
3950 #
3964 #
3951 3965 # return angles
3952 #
3966 #
3953 3967 # def __getHeights(self, Ranges, zenith, error, minHeight, maxHeight):
3954 #
3968 #
3955 3969 # Ramb = 375 #Ramb = c/(2*PRF)
3956 3970 # Re = 6371 #Earth Radius
3957 3971 # heights = numpy.zeros(Ranges.shape)
3958 #
3972 #
3959 3973 # R_aux = numpy.array([0,1,2])*Ramb
3960 3974 # R_aux = R_aux.reshape(1,R_aux.size)
3961 #
3975 #
3962 3976 # Ranges = Ranges.reshape(Ranges.size,1)
3963 #
3977 #
3964 3978 # Ri = Ranges + R_aux
3965 3979 # hi = numpy.sqrt(Re**2 + Ri**2 + (2*Re*numpy.cos(zenith*numpy.pi/180)*Ri.transpose()).transpose()) - Re
3966 #
3980 #
3967 3981 # #Check if there is a height between 70 and 110 km
3968 3982 # h_bool = numpy.sum(numpy.logical_and(hi > minHeight, hi < maxHeight), axis = 1)
3969 3983 # ind_h = numpy.where(h_bool == 1)[0]
3970 #
3984 #
3971 3985 # hCorr = hi[ind_h, :]
3972 3986 # ind_hCorr = numpy.where(numpy.logical_and(hi > minHeight, hi < maxHeight))
3973 #
3974 # hCorr = hi[ind_hCorr]
3987 #
3988 # hCorr = hi[ind_hCorr]
3975 3989 # heights[ind_h] = hCorr
3976 #
3990 #
3977 3991 # #Setting Error
3978 3992 # #Number 13: Height unresolvable echo: not valid height within 70 to 110 km
3979 # #Number 14: Height ambiguous echo: more than one possible height within 70 to 110 km
3980 #
3981 # indInvalid2 = numpy.where(numpy.logical_and(h_bool > 1, error == 0))[0]
3993 # #Number 14: Height ambiguous echo: more than one possible height within 70 to 110 km
3994 #
3995 # indInvalid2 = numpy.where(numpy.logical_and(h_bool > 1, error == 0))[0]
3982 3996 # error[indInvalid2] = 14
3983 3997 # indInvalid1 = numpy.where(numpy.logical_and(h_bool == 0, error == 0))[0]
3984 # error[indInvalid1] = 13
3985 #
3986 # return heights, error
3987 No newline at end of file
3998 # error[indInvalid1] = 13
3999 #
4000 # return heights, error
Show file before | Show file after | Hide comments
@@ -2,7 +2,7 import sys
2 2 import numpy,math
3 3 from scipy import interpolate
4 4 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
5 from schainpy.model.data.jrodata import Voltage
5 from schainpy.model.data.jrodata import Voltage,hildebrand_sekhon
6 6 from schainpy.utils import log
7 7 from time import time
8 8
@@ -1355,9 +1355,6 class PulsePairVoltage(Operation):
1355 1355 n,
1356 1356 dataOut.nHeights),
1357 1357 dtype='complex')
1358 #self.noise = numpy.zeros([self.__nch,self.__nHeis])
1359 #for i in range(self.__nch):
1360 # self.noise[i]=dataOut.getNoise(channel=i)
1361 1358
1362 1359 def putData(self,data):
1363 1360 '''
@@ -1372,101 +1369,127 class PulsePairVoltage(Operation):
1372 1369 Return the PULSEPAIR and the profiles used in the operation
1373 1370 Affected : self.__profileIndex
1374 1371 '''
1372 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Remove DCΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
1375 1373 if self.removeDC==True:
1376 1374 mean = numpy.mean(self.__buffer,1)
1377 1375 tmp = mean.reshape(self.__nch,1,self.__nHeis)
1378 1376 dc= numpy.tile(tmp,[1,self.__nProf,1])
1379 1377 self.__buffer = self.__buffer - dc
1378 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Calculo de Potencia Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
1379 pair0 = self.__buffer*numpy.conj(self.__buffer)
1380 pair0 = pair0.real
1381 lag_0 = numpy.sum(pair0,1)
1382 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Calculo de Ruido x canalΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
1383 self.noise = numpy.zeros(self.__nch)
1384 for i in range(self.__nch):
1385 daux = numpy.sort(pair0[i,:,:],axis= None)
1386 self.noise[i]=hildebrand_sekhon( daux ,self.nCohInt)
1387
1388 self.noise = self.noise.reshape(self.__nch,1)
1389 self.noise = numpy.tile(self.noise,[1,self.__nHeis])
1390 noise_buffer = self.noise.reshape(self.__nch,1,self.__nHeis)
1391 noise_buffer = numpy.tile(noise_buffer,[1,self.__nProf,1])
1392 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Potencia recibida= P , Potencia senal = S , Ruido= NΒ·Β·
1393 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· P= S+N ,P=lag_0/N Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
1394 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Power Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
1395 data_power = lag_0/(self.n*self.nCohInt)
1396 #------------------ Senal Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
1397 data_intensity = pair0 - noise_buffer
1398 data_intensity = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
1399 #data_intensity = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
1400 for i in range(self.__nch):
1401 for j in range(self.__nHeis):
1402 if data_intensity[i][j] < 0:
1403 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
1380 1404
1381 lag_0 = numpy.sum(self.__buffer*numpy.conj(self.__buffer),1)
1382 data_intensity = lag_0/(self.n*self.nCohInt)#*self.nCohInt)
1383
1405 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Calculo de Frecuencia y Velocidad dopplerΒ·Β·Β·Β·Β·Β·Β·Β·
1384 1406 pair1 = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
1385 1407 lag_1 = numpy.sum(pair1,1)
1386 #angle = numpy.angle(numpy.sum(pair1,1))*180/(math.pi)
1387 data_velocity = (-1.0*self.lambda_/(4*math.pi*self.ippSec))*numpy.angle(lag_1)#self.ippSec*self.nCohInt
1408 data_freq = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
1409 data_velocity = (self.lambda_/2.0)*data_freq
1388 1410
1389 self.noise = numpy.zeros([self.__nch,self.__nHeis])
1390 for i in range(self.__nch):
1391 self.noise[i]=dataOut.getNoise(channel=i)
1411 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Potencia promedio estimada de la SenalΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
1412 lag_0 = lag_0/self.n
1413 S = lag_0-self.noise
1392 1414
1393 lag_0 = lag_0.real/(self.n)
1415 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Frecuencia Doppler promedio Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
1394 1416 lag_1 = lag_1/(self.n-1)
1395 1417 R1 = numpy.abs(lag_1)
1396 S = (lag_0-self.noise)
1397 1418
1419 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Calculo del SNRΒ·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
1398 1420 data_snrPP = S/self.noise
1399 data_snrPP = numpy.where(data_snrPP<0,1,data_snrPP)
1421 for i in range(self.__nch):
1422 for j in range(self.__nHeis):
1423 if data_snrPP[i][j] < 1.e-20:
1424 data_snrPP[i][j] = 1.e-20
1400 1425
1426 #Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β· Calculo del ancho espectral Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·Β·
1401 1427 L = S/R1
1402 1428 L = numpy.where(L<0,1,L)
1403 1429 L = numpy.log(L)
1404
1405 1430 tmp = numpy.sqrt(numpy.absolute(L))
1406
1407 data_specwidth = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec))*tmp*numpy.sign(L)
1408 #data_specwidth = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec))*k
1431 data_specwidth = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec*self.nCohInt))*tmp*numpy.sign(L)
1409 1432 n = self.__profIndex
1410 1433
1411 1434 self.__buffer = numpy.zeros((self.__nch, self.__nProf,self.__nHeis), dtype='complex')
1412 1435 self.__profIndex = 0
1413 return data_intensity,data_velocity,data_snrPP,data_specwidth,n
1436 return data_power,data_intensity,data_velocity,data_snrPP,data_specwidth,n
1437
1414 1438
1415 1439 def pulsePairbyProfiles(self,dataOut):
1416 1440
1417 1441 self.__dataReady = False
1442 data_power = None
1418 1443 data_intensity = None
1419 1444 data_velocity = None
1420 1445 data_specwidth = None
1421 1446 data_snrPP = None
1422 1447 self.putData(data=dataOut.data)
1423 1448 if self.__profIndex == self.n:
1424 #self.noise = numpy.zeros([self.__nch,self.__nHeis])
1425 #for i in range(self.__nch):
1426 # self.noise[i]=data.getNoise(channel=i)
1427 #print(self.noise.shape)
1428 data_intensity, data_velocity,data_snrPP,data_specwidth, n = self.pushData(dataOut=dataOut)
1449 data_power,data_intensity, data_velocity,data_snrPP,data_specwidth, n = self.pushData(dataOut=dataOut)
1429 1450 self.__dataReady = True
1430 1451
1431 return data_intensity, data_velocity,data_snrPP,data_specwidth
1452 return data_power, data_intensity, data_velocity, data_snrPP, data_specwidth
1453
1432 1454
1433 1455 def pulsePairOp(self, dataOut, datatime= None):
1434 1456
1435 1457 if self.__initime == None:
1436 1458 self.__initime = datatime
1437 #print("hola")
1438 data_intensity, data_velocity,data_snrPP,data_specwidth = self.pulsePairbyProfiles(dataOut)
1459 data_power, data_intensity, data_velocity, data_snrPP, data_specwidth = self.pulsePairbyProfiles(dataOut)
1439 1460 self.__lastdatatime = datatime
1440 1461
1441 if data_intensity is None:
1442 return None, None,None,None,None
1462 if data_power is None:
1463 return None, None, None,None,None,None
1443 1464
1444 1465 avgdatatime = self.__initime
1445 1466 deltatime = datatime - self.__lastdatatime
1446 1467 self.__initime = datatime
1447 1468
1448 return data_intensity, data_velocity,data_snrPP,data_specwidth,avgdatatime
1469 return data_power, data_intensity, data_velocity, data_snrPP, data_specwidth, avgdatatime
1449 1470
1450 1471 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
1451 1472
1452 1473 if not self.isConfig:
1453 1474 self.setup(dataOut = dataOut, n = n , removeDC=removeDC , **kwargs)
1454 1475 self.isConfig = True
1455 data_intensity, data_velocity,data_snrPP,data_specwidth, avgdatatime = self.pulsePairOp(dataOut, dataOut.utctime)
1476 data_power, data_intensity, data_velocity,data_snrPP,data_specwidth, avgdatatime = self.pulsePairOp(dataOut, dataOut.utctime)
1456 1477 dataOut.flagNoData = True
1457 1478
1458 1479 if self.__dataReady:
1459 1480 dataOut.nCohInt *= self.n
1460 dataOut.data_intensity = data_intensity #valor para intensidad
1461 dataOut.data_velocity = data_velocity #valor para velocidad
1462 dataOut.data_snrPP = data_snrPP # valor para snr
1463 dataOut.data_specwidth = data_specwidth
1481 dataOut.dataPP_POW = data_intensity # S
1482 dataOut.dataPP_POWER = data_power # P
1483 dataOut.dataPP_DOP = data_velocity
1484 dataOut.dataPP_SNR = data_snrPP
1485 dataOut.dataPP_WIDTH = data_specwidth
1464 1486 dataOut.PRFbyAngle = self.n #numero de PRF*cada angulo rotado que equivale a un tiempo.
1465 1487 dataOut.utctime = avgdatatime
1466 1488 dataOut.flagNoData = False
1467 1489 return dataOut
1468 1490
1469 1491
1492
1470 1493 # import collections
1471 1494 # from scipy.stats import mode
1472 1495 #
Show file before | Show file after | Hide comments
@@ -25,8 +25,20 readUnitConfObj = controllerObj.addReadUnit(datatype='SimulatorReader',
25 25 delay=0,
26 26 online=0,
27 27 walk=0,
28 nTotalReadFiles=3)
29
28 profilesPerBlock=625,
29 dataBlocksPerFile=100)#,#nTotalReadFiles=2)
30 '''
31 readUnitConfObj = controllerObj.addReadUnit(datatype='VoltageReader',
32 path=path,
33 startDate="2020/01/01", #"2020/01/01",#today,
34 endDate= "2020/12/01", #"2020/12/30",#today,
35 startTime='00:00:00',
36 endTime='23:59:59',
37 delay=0,
38 #set=0,
39 online=0,
40 walk=1)
41 '''
30 42 opObj11 = readUnitConfObj.addOperation(name='printInfo')
31 43
32 44 procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
@@ -36,14 +48,26 procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=rea
36 48 #opObj10 = procUnitConfObjA.addOperation(name='selectChannels')
37 49 #opObj10.addParameter(name='channelList', value=[0])
38 50 opObj11 = procUnitConfObjA.addOperation(name='PulsePairVoltage', optype='other')
39 opObj11.addParameter(name='n', value='300', format='int')#10
51 opObj11.addParameter(name='n', value='625', format='int')#10
40 52 opObj11.addParameter(name='removeDC', value=1, format='int')
41 53
42 54 #opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
55 #opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
56
43 57
44 opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
58 #opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
45 59 #opObj11.addParameter(name='xmax', value=8)
46 60
47 opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
61 #opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
62
63 procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
64
65
66 opObj10 = procUnitConfObjB.addOperation(name='ParameterWriter')
67 opObj10.addParameter(name='path',value=figpath)
68 #opObj10.addParameter(name='mode',value=0)
69 opObj10.addParameter(name='blocksPerFile',value='100',format='int')
70 opObj10.addParameter(name='metadataList',value='utctimeInit,timeInterval',format='list')
71 opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,dataPP_SNR,dataPP_WIDTH')#,format='list'
48 72
49 73 controllerObj.start()
General Comments 0
You need to be logged in to leave comments. Login now