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