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