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