##// END OF EJS Templates
schain
RSS
Version 2.1.3.1
Miguel Valdez -
r669:350fc0523b69
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,31 +1,32
1 1 Prerequisites:
2 2
3 3 -numpy 1.8.0
4 4 -scipy
5 5 -math
6 6 -matplotlib
7 7 -h5py
8 8 -ftplib
9 9 -paramiko and scp (optional for using SendTFilesToServer)
10 10 -stuffr (optional for using jroIO_hf)
11 11 -PyQt4 (for using GUI)
12 -pyfits (Fits data)
12 13
13 14 Signal Chain Installation:
14 15
15 16 1. Install numpy, matplotlib, TKAgg
16 17 2. Install digital_rf_hdf5 module (developed by Haystack Observatory)
17 18 if you want to use USRP data
18 19 3. untar schainpy-x.x.x.tar.gz
19 20 4. cd schainpy-x.x.x
20 21 5. execute:
21 22 [hostname]$ sudo pyhon setup.py install
22 23 6. testing gui:
23 24 [hostname]$ schainGUI (enter)
24 25
25 26 If you want to use serialization and zerorpc you will need to install the next packages:
26 27
27 28 1. zerorpc
28 29 [hostname]$ sudo port install zerorpc
29 30
30 31 2. cPickle, msgpack and msgpack_numpy
31 32 [hostname]$ sudo port install cPickle msgpack mspack_numpy No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,15 +1,19
1 1 VERSIONS:
2 2
3 3 2.1.2:
4 4 -jroutils_ftp.py: Bug fixed, Any error sending file stopped the Server Thread
5 5 Server thread opens and closes remote server each time file list is sent
6 6 -jroplot_spectra.py: Noise path was not being created saving noise data.
7 7 -jroIO_base.py: startTime can be greater than endTime
8 8
9 9 2.1.3:
10 10 -jroplot_heispectra.py: SpectraHeisScope was not showing the right channels
11 11 -jroproc_voltage.py: Bug fixed selecting profiles (self.nProfiles took a wrong value),
12 12 Bug fixed selecting heights by block (selecting profiles instead heights)
13 13 -jroproc_voltage.py: New feature added: decoding data by block using FFT.
14 14 -jroIO_heispectra.py: Bug fixed in FitsReader. Using local Fits object instead schainpy.mode.data.jrodata.Fits object.
15 -jroIO_heispectra.py: Channel index list does not exist. No newline at end of file
15 -jroIO_heispectra.py: Channel index list does not exist.
16
17 2.1.3.1:
18 -GUI: every icon were resized
19 -jroproc_voltage.py: Print a message when "Read from code" option is selected and the code is not defined inside data file
Show file before | Show file after | Hide comments
@@ -1,7 +1,7
1 1 '''
2 2 Created on Feb 7, 2012
3 3
4 4 @author $Author$
5 5 @version $Id$
6 6 '''
7 __version__ = "2.1.3" No newline at end of file
7 __version__ = "2.1.3.1" No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,442 +1,442
1 1 import numpy
2 2 import datetime
3 3 import sys
4 4 import matplotlib
5 5
6 6 if 'linux' in sys.platform:
7 7 matplotlib.use("TKAgg")
8 8
9 9 if 'darwin' in sys.platform:
10 matplotlib.use("WXAgg")
10 matplotlib.use('GTKAgg')
11 11 #Qt4Agg', 'GTK', 'GTKAgg', 'ps', 'agg', 'cairo', 'MacOSX', 'GTKCairo', 'WXAgg', 'template', 'TkAgg', 'GTK3Cairo', 'GTK3Agg', 'svg', 'WebAgg', 'CocoaAgg', 'emf', 'gdk', 'WX'
12 12 import matplotlib.pyplot
13 13
14 14 from mpl_toolkits.axes_grid1 import make_axes_locatable
15 15 from matplotlib.ticker import *
16 16
17 17 ###########################################
18 18 #Actualizacion de las funciones del driver
19 19 ###########################################
20 20
21 21 def createFigure(id, wintitle, width, height, facecolor="w", show=True):
22 22
23 23 matplotlib.pyplot.ioff()
24 24 fig = matplotlib.pyplot.figure(num=id, facecolor=facecolor)
25 25 fig.canvas.manager.set_window_title(wintitle)
26 26 fig.canvas.manager.resize(width, height)
27 27 matplotlib.pyplot.ion()
28 28 if show:
29 29 matplotlib.pyplot.show()
30 30
31 31 return fig
32 32
33 33 def closeFigure(show=False, fig=None):
34 34
35 35 matplotlib.pyplot.ioff()
36 36 matplotlib.pyplot.pause(0.1)
37 37
38 38 if show:
39 39 matplotlib.pyplot.show()
40 40
41 41 if fig != None:
42 42 matplotlib.pyplot.close(fig)
43 43 matplotlib.pyplot.pause(0.1)
44 44 matplotlib.pyplot.ion()
45 45 return
46 46
47 47 matplotlib.pyplot.close("all")
48 48 matplotlib.pyplot.pause(0.1)
49 49 matplotlib.pyplot.ion()
50 50 return
51 51
52 52 def saveFigure(fig, filename):
53 53
54 54 matplotlib.pyplot.ioff()
55 55 fig.savefig(filename)
56 56 matplotlib.pyplot.ion()
57 57
58 58 def setWinTitle(fig, title):
59 59
60 60 fig.canvas.manager.set_window_title(title)
61 61
62 62 def setTitle(fig, title):
63 63
64 64 fig.suptitle(title)
65 65
66 66 def createAxes(fig, nrow, ncol, xpos, ypos, colspan, rowspan, polar=False):
67 67
68 68 matplotlib.pyplot.ioff()
69 69 matplotlib.pyplot.figure(fig.number)
70 70 axes = matplotlib.pyplot.subplot2grid((nrow, ncol),
71 71 (xpos, ypos),
72 72 colspan=colspan,
73 73 rowspan=rowspan,
74 74 polar=polar)
75 75
76 76 matplotlib.pyplot.ion()
77 77 return axes
78 78
79 79 def setAxesText(ax, text):
80 80
81 81 ax.annotate(text,
82 82 xy = (.1, .99),
83 83 xycoords = 'figure fraction',
84 84 horizontalalignment = 'left',
85 85 verticalalignment = 'top',
86 86 fontsize = 10)
87 87
88 88 def printLabels(ax, xlabel, ylabel, title):
89 89
90 90 ax.set_xlabel(xlabel, size=11)
91 91 ax.set_ylabel(ylabel, size=11)
92 92 ax.set_title(title, size=8)
93 93
94 94 def createPline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='',
95 95 ticksize=9, xtick_visible=True, ytick_visible=True,
96 96 nxticks=4, nyticks=10,
97 97 grid=None,color='blue'):
98 98
99 99 """
100 100
101 101 Input:
102 102 grid : None, 'both', 'x', 'y'
103 103 """
104 104
105 105 matplotlib.pyplot.ioff()
106 106
107 107 ax.set_xlim([xmin,xmax])
108 108 ax.set_ylim([ymin,ymax])
109 109
110 110 printLabels(ax, xlabel, ylabel, title)
111 111
112 112 ######################################################
113 113 if (xmax-xmin)<=1:
114 114 xtickspos = numpy.linspace(xmin,xmax,nxticks)
115 115 xtickspos = numpy.array([float("%.1f"%i) for i in xtickspos])
116 116 ax.set_xticks(xtickspos)
117 117 else:
118 118 xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
119 119 # xtickspos = numpy.arange(nxticks)*float(xmax-xmin)/float(nxticks) + int(xmin)
120 120 ax.set_xticks(xtickspos)
121 121
122 122 for tick in ax.get_xticklabels():
123 123 tick.set_visible(xtick_visible)
124 124
125 125 for tick in ax.xaxis.get_major_ticks():
126 126 tick.label.set_fontsize(ticksize)
127 127
128 128 ######################################################
129 129 for tick in ax.get_yticklabels():
130 130 tick.set_visible(ytick_visible)
131 131
132 132 for tick in ax.yaxis.get_major_ticks():
133 133 tick.label.set_fontsize(ticksize)
134 134
135 135 ax.plot(x, y, color=color)
136 136 iplot = ax.lines[-1]
137 137
138 138 ######################################################
139 139 if '0.' in matplotlib.__version__[0:2]:
140 140 print "The matplotlib version has to be updated to 1.1 or newer"
141 141 return iplot
142 142
143 143 if '1.0.' in matplotlib.__version__[0:4]:
144 144 print "The matplotlib version has to be updated to 1.1 or newer"
145 145 return iplot
146 146
147 147 if grid != None:
148 148 ax.grid(b=True, which='major', axis=grid)
149 149
150 150 matplotlib.pyplot.tight_layout()
151 151
152 152 matplotlib.pyplot.ion()
153 153
154 154 return iplot
155 155
156 156 def set_linedata(ax, x, y, idline):
157 157
158 158 ax.lines[idline].set_data(x,y)
159 159
160 160 def pline(iplot, x, y, xlabel='', ylabel='', title=''):
161 161
162 162 ax = iplot.get_axes()
163 163
164 164 printLabels(ax, xlabel, ylabel, title)
165 165
166 166 set_linedata(ax, x, y, idline=0)
167 167
168 168 def addpline(ax, x, y, color, linestyle, lw):
169 169
170 170 ax.plot(x,y,color=color,linestyle=linestyle,lw=lw)
171 171
172 172
173 173 def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
174 174 xlabel='', ylabel='', title='', ticksize = 9,
175 175 colormap='jet',cblabel='', cbsize="5%",
176 176 XAxisAsTime=False):
177 177
178 178 matplotlib.pyplot.ioff()
179 179
180 180 divider = make_axes_locatable(ax)
181 181 ax_cb = divider.new_horizontal(size=cbsize, pad=0.05)
182 182 fig = ax.get_figure()
183 183 fig.add_axes(ax_cb)
184 184
185 185 ax.set_xlim([xmin,xmax])
186 186 ax.set_ylim([ymin,ymax])
187 187
188 188 printLabels(ax, xlabel, ylabel, title)
189 189
190 190 imesh = ax.pcolormesh(x,y,z.T, vmin=zmin, vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
191 191 cb = matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
192 192 cb.set_label(cblabel)
193 193
194 194 # for tl in ax_cb.get_yticklabels():
195 195 # tl.set_visible(True)
196 196
197 197 for tick in ax.yaxis.get_major_ticks():
198 198 tick.label.set_fontsize(ticksize)
199 199
200 200 for tick in ax.xaxis.get_major_ticks():
201 201 tick.label.set_fontsize(ticksize)
202 202
203 203 for tick in cb.ax.get_yticklabels():
204 204 tick.set_fontsize(ticksize)
205 205
206 206 ax_cb.yaxis.tick_right()
207 207
208 208 if '0.' in matplotlib.__version__[0:2]:
209 209 print "The matplotlib version has to be updated to 1.1 or newer"
210 210 return imesh
211 211
212 212 if '1.0.' in matplotlib.__version__[0:4]:
213 213 print "The matplotlib version has to be updated to 1.1 or newer"
214 214 return imesh
215 215
216 216 matplotlib.pyplot.tight_layout()
217 217
218 218 if XAxisAsTime:
219 219
220 220 func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
221 221 ax.xaxis.set_major_formatter(FuncFormatter(func))
222 222 ax.xaxis.set_major_locator(LinearLocator(7))
223 223
224 224 matplotlib.pyplot.ion()
225 225 return imesh
226 226
227 227 def pcolor(imesh, z, xlabel='', ylabel='', title=''):
228 228
229 229 z = z.T
230 230 ax = imesh.get_axes()
231 231 printLabels(ax, xlabel, ylabel, title)
232 232 imesh.set_array(z.ravel())
233 233
234 234 def addpcolor(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
235 235
236 236 printLabels(ax, xlabel, ylabel, title)
237 237
238 238 ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
239 239
240 240 def addpcolorbuffer(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
241 241
242 242 printLabels(ax, xlabel, ylabel, title)
243 243
244 244 ax.collections.remove(ax.collections[0])
245 245
246 246 ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
247 247
248 248 def createPmultiline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
249 249 ticksize=9, xtick_visible=True, ytick_visible=True,
250 250 nxticks=4, nyticks=10,
251 251 grid=None):
252 252
253 253 """
254 254
255 255 Input:
256 256 grid : None, 'both', 'x', 'y'
257 257 """
258 258
259 259 matplotlib.pyplot.ioff()
260 260
261 261 lines = ax.plot(x.T, y)
262 262 leg = ax.legend(lines, legendlabels, loc='upper right')
263 263 leg.get_frame().set_alpha(0.5)
264 264 ax.set_xlim([xmin,xmax])
265 265 ax.set_ylim([ymin,ymax])
266 266 printLabels(ax, xlabel, ylabel, title)
267 267
268 268 xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
269 269 ax.set_xticks(xtickspos)
270 270
271 271 for tick in ax.get_xticklabels():
272 272 tick.set_visible(xtick_visible)
273 273
274 274 for tick in ax.xaxis.get_major_ticks():
275 275 tick.label.set_fontsize(ticksize)
276 276
277 277 for tick in ax.get_yticklabels():
278 278 tick.set_visible(ytick_visible)
279 279
280 280 for tick in ax.yaxis.get_major_ticks():
281 281 tick.label.set_fontsize(ticksize)
282 282
283 283 iplot = ax.lines[-1]
284 284
285 285 if '0.' in matplotlib.__version__[0:2]:
286 286 print "The matplotlib version has to be updated to 1.1 or newer"
287 287 return iplot
288 288
289 289 if '1.0.' in matplotlib.__version__[0:4]:
290 290 print "The matplotlib version has to be updated to 1.1 or newer"
291 291 return iplot
292 292
293 293 if grid != None:
294 294 ax.grid(b=True, which='major', axis=grid)
295 295
296 296 matplotlib.pyplot.tight_layout()
297 297
298 298 matplotlib.pyplot.ion()
299 299
300 300 return iplot
301 301
302 302
303 303 def pmultiline(iplot, x, y, xlabel='', ylabel='', title=''):
304 304
305 305 ax = iplot.get_axes()
306 306
307 307 printLabels(ax, xlabel, ylabel, title)
308 308
309 309 for i in range(len(ax.lines)):
310 310 line = ax.lines[i]
311 311 line.set_data(x[i,:],y)
312 312
313 313 def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
314 314 ticksize=9, xtick_visible=True, ytick_visible=True,
315 315 nxticks=4, nyticks=10, marker='.', markersize=10, linestyle="None",
316 316 grid=None, XAxisAsTime=False):
317 317
318 318 """
319 319
320 320 Input:
321 321 grid : None, 'both', 'x', 'y'
322 322 """
323 323
324 324 matplotlib.pyplot.ioff()
325 325
326 326 # lines = ax.plot(x, y.T, marker=marker,markersize=markersize,linestyle=linestyle)
327 327 lines = ax.plot(x, y.T, linestyle=linestyle, marker=marker, markersize=markersize)
328 328 leg = ax.legend(lines, legendlabels, loc='upper left', bbox_to_anchor=(1.01, 1.00), numpoints=1, handlelength=1.5, \
329 329 handletextpad=0.5, borderpad=0.5, labelspacing=0.5, borderaxespad=0.)
330 330
331 331 for label in leg.get_texts(): label.set_fontsize(9)
332 332
333 333 ax.set_xlim([xmin,xmax])
334 334 ax.set_ylim([ymin,ymax])
335 335 printLabels(ax, xlabel, ylabel, title)
336 336
337 337 # xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
338 338 # ax.set_xticks(xtickspos)
339 339
340 340 for tick in ax.get_xticklabels():
341 341 tick.set_visible(xtick_visible)
342 342
343 343 for tick in ax.xaxis.get_major_ticks():
344 344 tick.label.set_fontsize(ticksize)
345 345
346 346 for tick in ax.get_yticklabels():
347 347 tick.set_visible(ytick_visible)
348 348
349 349 for tick in ax.yaxis.get_major_ticks():
350 350 tick.label.set_fontsize(ticksize)
351 351
352 352 iplot = ax.lines[-1]
353 353
354 354 if '0.' in matplotlib.__version__[0:2]:
355 355 print "The matplotlib version has to be updated to 1.1 or newer"
356 356 return iplot
357 357
358 358 if '1.0.' in matplotlib.__version__[0:4]:
359 359 print "The matplotlib version has to be updated to 1.1 or newer"
360 360 return iplot
361 361
362 362 if grid != None:
363 363 ax.grid(b=True, which='major', axis=grid)
364 364
365 365 matplotlib.pyplot.tight_layout()
366 366
367 367 if XAxisAsTime:
368 368
369 369 func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
370 370 ax.xaxis.set_major_formatter(FuncFormatter(func))
371 371 ax.xaxis.set_major_locator(LinearLocator(7))
372 372
373 373 matplotlib.pyplot.ion()
374 374
375 375 return iplot
376 376
377 377 def pmultilineyaxis(iplot, x, y, xlabel='', ylabel='', title=''):
378 378
379 379 ax = iplot.get_axes()
380 380
381 381 printLabels(ax, xlabel, ylabel, title)
382 382
383 383 for i in range(len(ax.lines)):
384 384 line = ax.lines[i]
385 385 line.set_data(x,y[i,:])
386 386
387 387 def createPolar(ax, x, y,
388 388 xlabel='', ylabel='', title='', ticksize = 9,
389 389 colormap='jet',cblabel='', cbsize="5%",
390 390 XAxisAsTime=False):
391 391
392 392 matplotlib.pyplot.ioff()
393 393
394 394 ax.plot(x,y,'bo', markersize=5)
395 395 # ax.set_rmax(90)
396 396 ax.set_ylim(0,90)
397 397 ax.set_yticks(numpy.arange(0,90,20))
398 398 # ax.text(0, -110, ylabel, rotation='vertical', va ='center', ha = 'center' ,size='11')
399 399 # ax.text(0, 50, ylabel, rotation='vertical', va ='center', ha = 'left' ,size='11')
400 400 # ax.text(100, 100, 'example', ha='left', va='center', rotation='vertical')
401 401 ax.yaxis.labelpad = 230
402 402 printLabels(ax, xlabel, ylabel, title)
403 403 iplot = ax.lines[-1]
404 404
405 405 if '0.' in matplotlib.__version__[0:2]:
406 406 print "The matplotlib version has to be updated to 1.1 or newer"
407 407 return iplot
408 408
409 409 if '1.0.' in matplotlib.__version__[0:4]:
410 410 print "The matplotlib version has to be updated to 1.1 or newer"
411 411 return iplot
412 412
413 413 # if grid != None:
414 414 # ax.grid(b=True, which='major', axis=grid)
415 415
416 416 matplotlib.pyplot.tight_layout()
417 417
418 418 matplotlib.pyplot.ion()
419 419
420 420
421 421 return iplot
422 422
423 423 def polar(iplot, x, y, xlabel='', ylabel='', title=''):
424 424
425 425 ax = iplot.get_axes()
426 426
427 427 # ax.text(0, -110, ylabel, rotation='vertical', va ='center', ha = 'center',size='11')
428 428 printLabels(ax, xlabel, ylabel, title)
429 429
430 430 set_linedata(ax, x, y, idline=0)
431 431
432 432 def draw(fig):
433 433
434 434 if type(fig) == 'int':
435 435 raise ValueError, "Error drawing: Fig parameter should be a matplotlib figure object figure"
436 436
437 437 fig.canvas.draw()
438 438
439 439 def pause(interval=0.000001):
440 440
441 441 matplotlib.pyplot.pause(interval)
442 442 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1087 +1,1095
1 1 import numpy
2 2
3 3 from jroproc_base import ProcessingUnit, Operation
4 4 from schainpy.model.data.jrodata import Voltage
5 5
6 6 class VoltageProc(ProcessingUnit):
7 7
8 8
9 9 def __init__(self):
10 10
11 11 ProcessingUnit.__init__(self)
12 12
13 13 # self.objectDict = {}
14 14 self.dataOut = Voltage()
15 15 self.flip = 1
16 16
17 17 def run(self):
18 18 if self.dataIn.type == 'AMISR':
19 19 self.__updateObjFromAmisrInput()
20 20
21 21 if self.dataIn.type == 'Voltage':
22 22 self.dataOut.copy(self.dataIn)
23 23
24 24 # self.dataOut.copy(self.dataIn)
25 25
26 26 def __updateObjFromAmisrInput(self):
27 27
28 28 self.dataOut.timeZone = self.dataIn.timeZone
29 29 self.dataOut.dstFlag = self.dataIn.dstFlag
30 30 self.dataOut.errorCount = self.dataIn.errorCount
31 31 self.dataOut.useLocalTime = self.dataIn.useLocalTime
32 32
33 33 self.dataOut.flagNoData = self.dataIn.flagNoData
34 34 self.dataOut.data = self.dataIn.data
35 35 self.dataOut.utctime = self.dataIn.utctime
36 36 self.dataOut.channelList = self.dataIn.channelList
37 37 # self.dataOut.timeInterval = self.dataIn.timeInterval
38 38 self.dataOut.heightList = self.dataIn.heightList
39 39 self.dataOut.nProfiles = self.dataIn.nProfiles
40 40
41 41 self.dataOut.nCohInt = self.dataIn.nCohInt
42 42 self.dataOut.ippSeconds = self.dataIn.ippSeconds
43 43 self.dataOut.frequency = self.dataIn.frequency
44 44
45 45 self.dataOut.azimuth = self.dataIn.azimuth
46 46 self.dataOut.zenith = self.dataIn.zenith
47 47
48 48 self.dataOut.beam.codeList = self.dataIn.beam.codeList
49 49 self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
50 50 self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
51 51 #
52 52 # pass#
53 53 #
54 54 # def init(self):
55 55 #
56 56 #
57 57 # if self.dataIn.type == 'AMISR':
58 58 # self.__updateObjFromAmisrInput()
59 59 #
60 60 # if self.dataIn.type == 'Voltage':
61 61 # self.dataOut.copy(self.dataIn)
62 62 # # No necesita copiar en cada init() los atributos de dataIn
63 63 # # la copia deberia hacerse por cada nuevo bloque de datos
64 64
65 65 def selectChannels(self, channelList):
66 66
67 67 channelIndexList = []
68 68
69 69 for channel in channelList:
70 70 if channel not in self.dataOut.channelList:
71 71 raise ValueError, "Channel %d is not in %s" %(channel, str(self.dataOut.channelList))
72 72
73 73 index = self.dataOut.channelList.index(channel)
74 74 channelIndexList.append(index)
75 75
76 76 self.selectChannelsByIndex(channelIndexList)
77 77
78 78 def selectChannelsByIndex(self, channelIndexList):
79 79 """
80 80 Selecciona un bloque de datos en base a canales segun el channelIndexList
81 81
82 82 Input:
83 83 channelIndexList : lista sencilla de canales a seleccionar por ej. [2,3,7]
84 84
85 85 Affected:
86 86 self.dataOut.data
87 87 self.dataOut.channelIndexList
88 88 self.dataOut.nChannels
89 89 self.dataOut.m_ProcessingHeader.totalSpectra
90 90 self.dataOut.systemHeaderObj.numChannels
91 91 self.dataOut.m_ProcessingHeader.blockSize
92 92
93 93 Return:
94 94 None
95 95 """
96 96
97 97 for channelIndex in channelIndexList:
98 98 if channelIndex not in self.dataOut.channelIndexList:
99 99 print channelIndexList
100 100 raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
101 101
102 102 # nChannels = len(channelIndexList)
103 103 if self.dataOut.flagDataAsBlock:
104 104 """
105 105 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
106 106 """
107 107 data = self.dataOut.data[channelIndexList,:,:]
108 108 else:
109 109 data = self.dataOut.data[channelIndexList,:]
110 110
111 111 self.dataOut.data = data
112 112 self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
113 113 # self.dataOut.nChannels = nChannels
114 114
115 115 return 1
116 116
117 117 def selectHeights(self, minHei=None, maxHei=None):
118 118 """
119 119 Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
120 120 minHei <= height <= maxHei
121 121
122 122 Input:
123 123 minHei : valor minimo de altura a considerar
124 124 maxHei : valor maximo de altura a considerar
125 125
126 126 Affected:
127 127 Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
128 128
129 129 Return:
130 130 1 si el metodo se ejecuto con exito caso contrario devuelve 0
131 131 """
132 132
133 133 if minHei == None:
134 134 minHei = self.dataOut.heightList[0]
135 135
136 136 if maxHei == None:
137 137 maxHei = self.dataOut.heightList[-1]
138 138
139 139 if (minHei < self.dataOut.heightList[0]):
140 140 minHei = self.dataOut.heightList[0]
141 141 # raise ValueError, "height range [%d,%d] is not valid. Data height range is [%d, %d]" % (minHei,
142 142 # maxHei,
143 143 # self.dataOut.heightList[0],
144 144 # self.dataOut.heightList[-1])
145 145
146 146 if (maxHei > self.dataOut.heightList[-1]):
147 147 maxHei = self.dataOut.heightList[-1]
148 148 # raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
149 149
150 150 minIndex = 0
151 151 maxIndex = 0
152 152 heights = self.dataOut.heightList
153 153
154 154 inda = numpy.where(heights >= minHei)
155 155 indb = numpy.where(heights <= maxHei)
156 156
157 157 try:
158 158 minIndex = inda[0][0]
159 159 except:
160 160 minIndex = 0
161 161
162 162 try:
163 163 maxIndex = indb[0][-1]
164 164 except:
165 165 maxIndex = len(heights)
166 166
167 167 self.selectHeightsByIndex(minIndex, maxIndex)
168 168
169 169 return 1
170 170
171 171
172 172 def selectHeightsByIndex(self, minIndex, maxIndex):
173 173 """
174 174 Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
175 175 minIndex <= index <= maxIndex
176 176
177 177 Input:
178 178 minIndex : valor de indice minimo de altura a considerar
179 179 maxIndex : valor de indice maximo de altura a considerar
180 180
181 181 Affected:
182 182 self.dataOut.data
183 183 self.dataOut.heightList
184 184
185 185 Return:
186 186 1 si el metodo se ejecuto con exito caso contrario devuelve 0
187 187 """
188 188
189 189 if (minIndex < 0) or (minIndex > maxIndex):
190 190 raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
191 191
192 192 if (maxIndex >= self.dataOut.nHeights):
193 193 maxIndex = self.dataOut.nHeights
194 194 # raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
195 195
196 196 # nHeights = maxIndex - minIndex + 1
197 197
198 198 #voltage
199 199 if self.dataOut.flagDataAsBlock:
200 200 """
201 201 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
202 202 """
203 203 data = self.dataOut.data[:,:, minIndex:maxIndex]
204 204 else:
205 205 data = self.dataOut.data[:, minIndex:maxIndex]
206 206
207 207 # firstHeight = self.dataOut.heightList[minIndex]
208 208
209 209 self.dataOut.data = data
210 210 self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex]
211 211
212 212 if self.dataOut.nHeights <= 1:
213 213 raise ValueError, "selectHeights: Too few heights. Current number of heights is %d" %(self.dataOut.nHeights)
214 214
215 215 return 1
216 216
217 217
218 218 def filterByHeights(self, window):
219 219
220 220 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
221 221
222 222 if window == None:
223 223 window = (self.dataOut.radarControllerHeaderObj.txA/self.dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
224 224
225 225 newdelta = deltaHeight * window
226 226 r = self.dataOut.nHeights % window
227 227 newheights = (self.dataOut.nHeights-r)/window
228 228
229 229 if newheights <= 1:
230 230 raise ValueError, "filterByHeights: Too few heights. Current number of heights is %d and window is %d" %(self.dataOut.nHeights, window)
231 231
232 232 if self.dataOut.flagDataAsBlock:
233 233 """
234 234 Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
235 235 """
236 236 buffer = self.dataOut.data[:, :, 0:self.dataOut.nHeights-r]
237 237 buffer = buffer.reshape(self.dataOut.nChannels,self.dataOut.nProfiles,self.dataOut.nHeights/window,window)
238 238 buffer = numpy.sum(buffer,3)
239 239
240 240 else:
241 241 buffer = self.dataOut.data[:,0:self.dataOut.nHeights-r]
242 242 buffer = buffer.reshape(self.dataOut.nChannels,self.dataOut.nHeights/window,window)
243 243 buffer = numpy.sum(buffer,2)
244 244
245 245 self.dataOut.data = buffer
246 246 self.dataOut.heightList = self.dataOut.heightList[0] + numpy.arange( newheights )*newdelta
247 247 self.dataOut.windowOfFilter = window
248 248
249 249 def setH0(self, h0, deltaHeight = None):
250 250
251 251 if not deltaHeight:
252 252 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
253 253
254 254 nHeights = self.dataOut.nHeights
255 255
256 256 newHeiRange = h0 + numpy.arange(nHeights)*deltaHeight
257 257
258 258 self.dataOut.heightList = newHeiRange
259 259
260 260 def deFlip(self, channelList = []):
261 261
262 262 data = self.dataOut.data.copy()
263 263
264 264 if self.dataOut.flagDataAsBlock:
265 265 flip = self.flip
266 266 profileList = range(self.dataOut.nProfiles)
267 267
268 268 if not channelList:
269 269 for thisProfile in profileList:
270 270 data[:,thisProfile,:] = data[:,thisProfile,:]*flip
271 271 flip *= -1.0
272 272 else:
273 273 for thisChannel in channelList:
274 274 if thisChannel not in self.dataOut.channelList:
275 275 continue
276 276
277 277 for thisProfile in profileList:
278 278 data[thisChannel,thisProfile,:] = data[thisChannel,thisProfile,:]*flip
279 279 flip *= -1.0
280 280
281 281 self.flip = flip
282 282
283 283 else:
284 284 if not channelList:
285 285 data[:,:] = data[:,:]*self.flip
286 286 else:
287 287 for thisChannel in channelList:
288 288 if thisChannel not in self.dataOut.channelList:
289 289 continue
290 290
291 291 data[thisChannel,:] = data[thisChannel,:]*self.flip
292 292
293 293 self.flip *= -1.
294 294
295 295 self.dataOut.data = data
296 296
297 297 def setRadarFrequency(self, frequency=None):
298 298
299 299 if frequency != None:
300 300 self.dataOut.frequency = frequency
301 301
302 302 return 1
303 303
304 304 class CohInt(Operation):
305 305
306 306 isConfig = False
307 307
308 308 __profIndex = 0
309 309 __withOverapping = False
310 310
311 311 __byTime = False
312 312 __initime = None
313 313 __lastdatatime = None
314 314 __integrationtime = None
315 315
316 316 __buffer = None
317 317
318 318 __dataReady = False
319 319
320 320 n = None
321 321
322 322
323 323 def __init__(self):
324 324
325 325 Operation.__init__(self)
326 326
327 327 # self.isConfig = False
328 328
329 329 def setup(self, n=None, timeInterval=None, overlapping=False, byblock=False):
330 330 """
331 331 Set the parameters of the integration class.
332 332
333 333 Inputs:
334 334
335 335 n : Number of coherent integrations
336 336 timeInterval : Time of integration. If the parameter "n" is selected this one does not work
337 337 overlapping :
338 338
339 339 """
340 340
341 341 self.__initime = None
342 342 self.__lastdatatime = 0
343 343 self.__buffer = None
344 344 self.__dataReady = False
345 345 self.byblock = byblock
346 346
347 347 if n == None and timeInterval == None:
348 348 raise ValueError, "n or timeInterval should be specified ..."
349 349
350 350 if n != None:
351 351 self.n = n
352 352 self.__byTime = False
353 353 else:
354 354 self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
355 355 self.n = 9999
356 356 self.__byTime = True
357 357
358 358 if overlapping:
359 359 self.__withOverapping = True
360 360 self.__buffer = None
361 361 else:
362 362 self.__withOverapping = False
363 363 self.__buffer = 0
364 364
365 365 self.__profIndex = 0
366 366
367 367 def putData(self, data):
368 368
369 369 """
370 370 Add a profile to the __buffer and increase in one the __profileIndex
371 371
372 372 """
373 373
374 374 if not self.__withOverapping:
375 375 self.__buffer += data.copy()
376 376 self.__profIndex += 1
377 377 return
378 378
379 379 #Overlapping data
380 380 nChannels, nHeis = data.shape
381 381 data = numpy.reshape(data, (1, nChannels, nHeis))
382 382
383 383 #If the buffer is empty then it takes the data value
384 384 if self.__buffer is None:
385 385 self.__buffer = data
386 386 self.__profIndex += 1
387 387 return
388 388
389 389 #If the buffer length is lower than n then stakcing the data value
390 390 if self.__profIndex < self.n:
391 391 self.__buffer = numpy.vstack((self.__buffer, data))
392 392 self.__profIndex += 1
393 393 return
394 394
395 395 #If the buffer length is equal to n then replacing the last buffer value with the data value
396 396 self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
397 397 self.__buffer[self.n-1] = data
398 398 self.__profIndex = self.n
399 399 return
400 400
401 401
402 402 def pushData(self):
403 403 """
404 404 Return the sum of the last profiles and the profiles used in the sum.
405 405
406 406 Affected:
407 407
408 408 self.__profileIndex
409 409
410 410 """
411 411
412 412 if not self.__withOverapping:
413 413 data = self.__buffer
414 414 n = self.__profIndex
415 415
416 416 self.__buffer = 0
417 417 self.__profIndex = 0
418 418
419 419 return data, n
420 420
421 421 #Integration with Overlapping
422 422 data = numpy.sum(self.__buffer, axis=0)
423 423 n = self.__profIndex
424 424
425 425 return data, n
426 426
427 427 def byProfiles(self, data):
428 428
429 429 self.__dataReady = False
430 430 avgdata = None
431 431 # n = None
432 432
433 433 self.putData(data)
434 434
435 435 if self.__profIndex == self.n:
436 436
437 437 avgdata, n = self.pushData()
438 438 self.__dataReady = True
439 439
440 440 return avgdata
441 441
442 442 def byTime(self, data, datatime):
443 443
444 444 self.__dataReady = False
445 445 avgdata = None
446 446 n = None
447 447
448 448 self.putData(data)
449 449
450 450 if (datatime - self.__initime) >= self.__integrationtime:
451 451 avgdata, n = self.pushData()
452 452 self.n = n
453 453 self.__dataReady = True
454 454
455 455 return avgdata
456 456
457 457 def integrate(self, data, datatime=None):
458 458
459 459 if self.__initime == None:
460 460 self.__initime = datatime
461 461
462 462 if self.__byTime:
463 463 avgdata = self.byTime(data, datatime)
464 464 else:
465 465 avgdata = self.byProfiles(data)
466 466
467 467
468 468 self.__lastdatatime = datatime
469 469
470 470 if avgdata is None:
471 471 return None, None
472 472
473 473 avgdatatime = self.__initime
474 474
475 475 deltatime = datatime -self.__lastdatatime
476 476
477 477 if not self.__withOverapping:
478 478 self.__initime = datatime
479 479 else:
480 480 self.__initime += deltatime
481 481
482 482 return avgdata, avgdatatime
483 483
484 484 def integrateByBlock(self, dataOut):
485 485
486 486 times = int(dataOut.data.shape[1]/self.n)
487 487 avgdata = numpy.zeros((dataOut.nChannels, times, dataOut.nHeights), dtype=numpy.complex)
488 488
489 489 id_min = 0
490 490 id_max = self.n
491 491
492 492 for i in range(times):
493 493 junk = dataOut.data[:,id_min:id_max,:]
494 494 avgdata[:,i,:] = junk.sum(axis=1)
495 495 id_min += self.n
496 496 id_max += self.n
497 497
498 498 timeInterval = dataOut.ippSeconds*self.n
499 499 avgdatatime = (times - 1) * timeInterval + dataOut.utctime
500 500 self.__dataReady = True
501 501 return avgdata, avgdatatime
502 502
503 503 def run(self, dataOut, **kwargs):
504 504
505 505 if not self.isConfig:
506 506 self.setup(**kwargs)
507 507 self.isConfig = True
508 508
509 509 if dataOut.flagDataAsBlock:
510 510 """
511 511 Si la data es leida por bloques, dimension = [nChannels, nProfiles, nHeis]
512 512 """
513 513 avgdata, avgdatatime = self.integrateByBlock(dataOut)
514 514 else:
515 515 avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
516 516
517 517 # dataOut.timeInterval *= n
518 518 dataOut.flagNoData = True
519 519
520 520 if self.__dataReady:
521 521 dataOut.data = avgdata
522 522 dataOut.nCohInt *= self.n
523 523 dataOut.utctime = avgdatatime
524 524 # dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
525 525 dataOut.flagNoData = False
526 526
527 527 class Decoder(Operation):
528 528
529 529 isConfig = False
530 530 __profIndex = 0
531 531
532 532 code = None
533 533
534 534 nCode = None
535 535 nBaud = None
536 536
537 537
538 538 def __init__(self):
539 539
540 540 Operation.__init__(self)
541 541
542 542 self.times = None
543 543 self.osamp = None
544 544 # self.__setValues = False
545 545 self.isConfig = False
546 546
547 547 def setup(self, code, osamp, dataOut):
548 548
549 549 self.__profIndex = 0
550 550
551 551 self.code = code
552 552
553 553 self.nCode = len(code)
554 554 self.nBaud = len(code[0])
555 555
556 556 if (osamp != None) and (osamp >1):
557 557 self.osamp = osamp
558 558 self.code = numpy.repeat(code, repeats=self.osamp, axis=1)
559 559 self.nBaud = self.nBaud*self.osamp
560 560
561 561 self.__nChannels = dataOut.nChannels
562 562 self.__nProfiles = dataOut.nProfiles
563 563 self.__nHeis = dataOut.nHeights
564 564
565 565 if self.__nHeis < self.nBaud:
566 566 print 'IOError: Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud)
567 567 raise IOError, 'Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud)
568 568
569 569 #Frequency
570 570 __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
571 571
572 572 __codeBuffer[:,0:self.nBaud] = self.code
573 573
574 574 self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
575 575
576 576 if dataOut.flagDataAsBlock:
577 577
578 578 self.ndatadec = self.__nHeis #- self.nBaud + 1
579 579
580 580 self.datadecTime = numpy.zeros((self.__nChannels, self.__nProfiles, self.ndatadec), dtype=numpy.complex)
581 581
582 582 else:
583 583
584 584 #Time
585 585 self.ndatadec = self.__nHeis #- self.nBaud + 1
586 586
587 587 self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
588 588
589 589 def __convolutionInFreq(self, data):
590 590
591 591 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
592 592
593 593 fft_data = numpy.fft.fft(data, axis=1)
594 594
595 595 conv = fft_data*fft_code
596 596
597 597 data = numpy.fft.ifft(conv,axis=1)
598 598
599 599 return data
600 600
601 601 def __convolutionInFreqOpt(self, data):
602 602
603 603 raise NotImplementedError
604 604
605 605 # fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
606 606 #
607 607 # data = cfunctions.decoder(fft_code, data)
608 608 #
609 609 # datadec = data#[:,:]
610 610 #
611 611 # return datadec
612 612
613 613 def __convolutionInTime(self, data):
614 614
615 615 code = self.code[self.__profIndex]
616 616
617 617 for i in range(self.__nChannels):
618 618 self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='full')[self.nBaud-1:]
619 619
620 620 return self.datadecTime
621 621
622 622 def __convolutionByBlockInTime(self, data):
623 623
624 624 repetitions = self.__nProfiles / self.nCode
625 625
626 626 junk = numpy.lib.stride_tricks.as_strided(self.code, (repetitions, self.code.size), (0, self.code.itemsize))
627 627 junk = junk.flatten()
628 628 code_block = numpy.reshape(junk, (self.nCode*repetitions, self.nBaud))
629 629
630 630 for i in range(self.__nChannels):
631 631 for j in range(self.__nProfiles):
632 632 self.datadecTime[i,j,:] = numpy.correlate(data[i,j,:], code_block[j,:], mode='full')[self.nBaud-1:]
633 633
634 634 return self.datadecTime
635 635
636 636 def __convolutionByBlockInFreq(self, data):
637 637
638 638 fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
639 639
640 640 fft_data = numpy.fft.fft(data, axis=2)
641 641
642 642 conv = fft_data*fft_code
643 643
644 644 data = numpy.fft.ifft(conv,axis=2)
645 645
646 646 return data
647 647
648 648 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0, osamp=None, times=None):
649 649
650 dataOut.flagNoData = True
651
650 652 if dataOut.flagDecodeData:
651 653 print "This data is already decoded, recoding again ..."
652 654
653 655 if not self.isConfig:
654 656
655 657 if code is None:
658 if not dataOut.code:
659 print "Code is not defined"
660 raise ValueError, "Code could not be read from %s object. Enter a value in Code parameter" %dataOut.type
661
656 662 code = dataOut.code
657 663 else:
658 664 code = numpy.array(code).reshape(nCode,nBaud)
659 665
660 666 self.setup(code, osamp, dataOut)
661 667
662 668 self.isConfig = True
663 669
664 670 if self.code is None:
665 671 print "Fail decoding: Code is not defined."
666 672 return
667 673
668 674 datadec = None
669 675
670 676 if dataOut.flagDataAsBlock:
671 677 """
672 678 Decoding when data have been read as block,
673 679 """
674 680 if mode == 0:
675 681 datadec = self.__convolutionByBlockInTime(dataOut.data)
676 682 if mode == 1:
677 683 datadec = self.__convolutionByBlockInFreq(dataOut.data)
678 684 else:
679 685 """
680 686 Decoding when data have been read profile by profile
681 687 """
682 688 if mode == 0:
683 689 datadec = self.__convolutionInTime(dataOut.data)
684 690
685 691 if mode == 1:
686 692 datadec = self.__convolutionInFreq(dataOut.data)
687 693
688 694 if mode == 2:
689 695 datadec = self.__convolutionInFreqOpt(dataOut.data)
690 696
691 697 if datadec is None:
692 698 raise ValueError, "Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode
693 699
694 700 dataOut.code = self.code
695 701 dataOut.nCode = self.nCode
696 702 dataOut.nBaud = self.nBaud
697 703
698 704 dataOut.data = datadec
699 705
700 706 dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
701 707
702 708 dataOut.flagDecodeData = True #asumo q la data esta decodificada
703 709
704 710 if self.__profIndex == self.nCode-1:
705 711 self.__profIndex = 0
706 712 return 1
707 713
708 714 self.__profIndex += 1
709 715
716 dataOut.flagNoData = False
717
710 718 return 1
711 719 # dataOut.flagDeflipData = True #asumo q la data no esta sin flip
712 720
713 721
714 722 class ProfileConcat(Operation):
715 723
716 724 isConfig = False
717 725 buffer = None
718 726
719 727 def __init__(self):
720 728
721 729 Operation.__init__(self)
722 730 self.profileIndex = 0
723 731
724 732 def reset(self):
725 733 self.buffer = numpy.zeros_like(self.buffer)
726 734 self.start_index = 0
727 735 self.times = 1
728 736
729 737 def setup(self, data, m, n=1):
730 738 self.buffer = numpy.zeros((data.shape[0],data.shape[1]*m),dtype=type(data[0,0]))
731 739 self.nHeights = data.nHeights
732 740 self.start_index = 0
733 741 self.times = 1
734 742
735 743 def concat(self, data):
736 744
737 745 self.buffer[:,self.start_index:self.profiles*self.times] = data.copy()
738 746 self.start_index = self.start_index + self.nHeights
739 747
740 748 def run(self, dataOut, m):
741 749
742 750 dataOut.flagNoData = True
743 751
744 752 if not self.isConfig:
745 753 self.setup(dataOut.data, m, 1)
746 754 self.isConfig = True
747 755
748 756 if dataOut.flagDataAsBlock:
749 757
750 758 raise ValueError, "ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False"
751 759
752 760 else:
753 761 self.concat(dataOut.data)
754 762 self.times += 1
755 763 if self.times > m:
756 764 dataOut.data = self.buffer
757 765 self.reset()
758 766 dataOut.flagNoData = False
759 767 # se deben actualizar mas propiedades del header y del objeto dataOut, por ejemplo, las alturas
760 768 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
761 769 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * m
762 770 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
763 771 dataOut.ippSeconds *= m
764 772
765 773 class ProfileSelector(Operation):
766 774
767 775 profileIndex = None
768 776 # Tamanho total de los perfiles
769 777 nProfiles = None
770 778
771 779 def __init__(self):
772 780
773 781 Operation.__init__(self)
774 782 self.profileIndex = 0
775 783
776 784 def incIndex(self):
777 785
778 786 self.profileIndex += 1
779 787
780 788 if self.profileIndex >= self.nProfiles:
781 789 self.profileIndex = 0
782 790
783 791 def isThisProfileInRange(self, profileIndex, minIndex, maxIndex):
784 792
785 793 if profileIndex < minIndex:
786 794 return False
787 795
788 796 if profileIndex > maxIndex:
789 797 return False
790 798
791 799 return True
792 800
793 801 def isThisProfileInList(self, profileIndex, profileList):
794 802
795 803 if profileIndex not in profileList:
796 804 return False
797 805
798 806 return True
799 807
800 808 def run(self, dataOut, profileList=None, profileRangeList=None, beam=None, byblock=False, rangeList = None, nProfiles=None):
801 809
802 810 """
803 811 ProfileSelector:
804 812
805 813 Inputs:
806 814 profileList : Index of profiles selected. Example: profileList = (0,1,2,7,8)
807 815
808 816 profileRangeList : Minimum and maximum profile indexes. Example: profileRangeList = (4, 30)
809 817
810 818 rangeList : List of profile ranges. Example: rangeList = ((4, 30), (32, 64), (128, 256))
811 819
812 820 """
813 821
814 822 dataOut.flagNoData = True
815 823
816 824 if dataOut.flagDataAsBlock:
817 825 """
818 826 data dimension = [nChannels, nProfiles, nHeis]
819 827 """
820 828 if profileList != None:
821 829 dataOut.data = dataOut.data[:,profileList,:]
822 830 dataOut.nProfiles = len(profileList)
823 831 dataOut.profileIndex = dataOut.nProfiles - 1
824 832
825 833 if profileRangeList != None:
826 834 minIndex = profileRangeList[0]
827 835 maxIndex = profileRangeList[1]
828 836
829 837 dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
830 838 dataOut.nProfiles = maxIndex - minIndex + 1
831 839 dataOut.profileIndex = dataOut.nProfiles - 1
832 840
833 841 if rangeList != None:
834 842 raise ValueError, "Profile Selector: Invalid argument rangeList. Not implemented for getByBlock yet"
835 843
836 844 dataOut.flagNoData = False
837 845
838 846 return True
839 847
840 848 """
841 849 data dimension = [nChannels, nHeis]
842 850 """
843 851
844 852 if nProfiles:
845 853 self.nProfiles = nProfiles
846 854 else:
847 855 self.nProfiles = dataOut.nProfiles
848 856
849 857 if profileList != None:
850 858
851 859 dataOut.nProfiles = len(profileList)
852 860
853 861 if self.isThisProfileInList(dataOut.profileIndex, profileList):
854 862 dataOut.flagNoData = False
855 863 dataOut.profileIndex = self.profileIndex
856 864
857 865 self.incIndex()
858 866 return True
859 867
860 868 if profileRangeList != None:
861 869
862 870 minIndex = profileRangeList[0]
863 871 maxIndex = profileRangeList[1]
864 872
865 873 dataOut.nProfiles = maxIndex - minIndex + 1
866 874
867 875 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
868 876 dataOut.flagNoData = False
869 877 dataOut.profileIndex = self.profileIndex
870 878
871 879 self.incIndex()
872 880 return True
873 881
874 882 if rangeList != None:
875 883
876 884 nProfiles = 0
877 885
878 886 for thisRange in rangeList:
879 887 minIndex = thisRange[0]
880 888 maxIndex = thisRange[1]
881 889
882 890 nProfiles += maxIndex - minIndex + 1
883 891
884 892 dataOut.nProfiles = nProfiles
885 893
886 894 for thisRange in rangeList:
887 895
888 896 minIndex = thisRange[0]
889 897 maxIndex = thisRange[1]
890 898
891 899 if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
892 900
893 901 # print "profileIndex = ", dataOut.profileIndex
894 902
895 903 dataOut.flagNoData = False
896 904 dataOut.profileIndex = self.profileIndex
897 905
898 906 self.incIndex()
899 907 break
900 908 return True
901 909
902 910
903 911 if beam != None: #beam is only for AMISR data
904 912 if self.isThisProfileInList(dataOut.profileIndex, dataOut.beamRangeDict[beam]):
905 913 dataOut.flagNoData = False
906 914 dataOut.profileIndex = self.profileIndex
907 915
908 916 self.incIndex()
909 917
910 918 return True
911 919
912 920 raise ValueError, "ProfileSelector needs profileList, profileRangeList or rangeList parameter"
913 921
914 922 return False
915 923
916 924
917 925
918 926 class Reshaper(Operation):
919 927
920 928 def __init__(self):
921 929
922 930 Operation.__init__(self)
923 931 self.updateNewHeights = True
924 932
925 933 def run(self, dataOut, shape):
926 934
927 935 if not dataOut.flagDataAsBlock:
928 936 raise ValueError, "Reshaper can only be used when voltage have been read as Block, getBlock = True"
929 937
930 938 if len(shape) != 3:
931 939 raise ValueError, "shape len should be equal to 3, (nChannels, nProfiles, nHeis)"
932 940
933 941 shape_tuple = tuple(shape)
934 942 dataOut.data = numpy.reshape(dataOut.data, shape_tuple)
935 943 dataOut.flagNoData = False
936 944
937 945 if self.updateNewHeights:
938 946
939 947 old_nheights = dataOut.nHeights
940 948 new_nheights = dataOut.data.shape[2]
941 949 factor = 1.0*new_nheights / old_nheights
942 950
943 951 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
944 952
945 953 xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * factor
946 954
947 955 dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
948 956
949 957 dataOut.nProfiles = dataOut.data.shape[1]
950 958
951 959 dataOut.ippSeconds *= factor
952 960 #
953 961 # import collections
954 962 # from scipy.stats import mode
955 963 #
956 964 # class Synchronize(Operation):
957 965 #
958 966 # isConfig = False
959 967 # __profIndex = 0
960 968 #
961 969 # def __init__(self):
962 970 #
963 971 # Operation.__init__(self)
964 972 # # self.isConfig = False
965 973 # self.__powBuffer = None
966 974 # self.__startIndex = 0
967 975 # self.__pulseFound = False
968 976 #
969 977 # def __findTxPulse(self, dataOut, channel=0, pulse_with = None):
970 978 #
971 979 # #Read data
972 980 #
973 981 # powerdB = dataOut.getPower(channel = channel)
974 982 # noisedB = dataOut.getNoise(channel = channel)[0]
975 983 #
976 984 # self.__powBuffer.extend(powerdB.flatten())
977 985 #
978 986 # dataArray = numpy.array(self.__powBuffer)
979 987 #
980 988 # filteredPower = numpy.correlate(dataArray, dataArray[0:self.__nSamples], "same")
981 989 #
982 990 # maxValue = numpy.nanmax(filteredPower)
983 991 #
984 992 # if maxValue < noisedB + 10:
985 993 # #No se encuentra ningun pulso de transmision
986 994 # return None
987 995 #
988 996 # maxValuesIndex = numpy.where(filteredPower > maxValue - 0.1*abs(maxValue))[0]
989 997 #
990 998 # if len(maxValuesIndex) < 2:
991 999 # #Solo se encontro un solo pulso de transmision de un baudio, esperando por el siguiente TX
992 1000 # return None
993 1001 #
994 1002 # phasedMaxValuesIndex = maxValuesIndex - self.__nSamples
995 1003 #
996 1004 # #Seleccionar solo valores con un espaciamiento de nSamples
997 1005 # pulseIndex = numpy.intersect1d(maxValuesIndex, phasedMaxValuesIndex)
998 1006 #
999 1007 # if len(pulseIndex) < 2:
1000 1008 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1001 1009 # return None
1002 1010 #
1003 1011 # spacing = pulseIndex[1:] - pulseIndex[:-1]
1004 1012 #
1005 1013 # #remover senales que se distancien menos de 10 unidades o muestras
1006 1014 # #(No deberian existir IPP menor a 10 unidades)
1007 1015 #
1008 1016 # realIndex = numpy.where(spacing > 10 )[0]
1009 1017 #
1010 1018 # if len(realIndex) < 2:
1011 1019 # #Solo se encontro un pulso de transmision con ancho mayor a 1
1012 1020 # return None
1013 1021 #
1014 1022 # #Eliminar pulsos anchos (deja solo la diferencia entre IPPs)
1015 1023 # realPulseIndex = pulseIndex[realIndex]
1016 1024 #
1017 1025 # period = mode(realPulseIndex[1:] - realPulseIndex[:-1])[0][0]
1018 1026 #
1019 1027 # print "IPP = %d samples" %period
1020 1028 #
1021 1029 # self.__newNSamples = dataOut.nHeights #int(period)
1022 1030 # self.__startIndex = int(realPulseIndex[0])
1023 1031 #
1024 1032 # return 1
1025 1033 #
1026 1034 #
1027 1035 # def setup(self, nSamples, nChannels, buffer_size = 4):
1028 1036 #
1029 1037 # self.__powBuffer = collections.deque(numpy.zeros( buffer_size*nSamples,dtype=numpy.float),
1030 1038 # maxlen = buffer_size*nSamples)
1031 1039 #
1032 1040 # bufferList = []
1033 1041 #
1034 1042 # for i in range(nChannels):
1035 1043 # bufferByChannel = collections.deque(numpy.zeros( buffer_size*nSamples, dtype=numpy.complex) + numpy.NAN,
1036 1044 # maxlen = buffer_size*nSamples)
1037 1045 #
1038 1046 # bufferList.append(bufferByChannel)
1039 1047 #
1040 1048 # self.__nSamples = nSamples
1041 1049 # self.__nChannels = nChannels
1042 1050 # self.__bufferList = bufferList
1043 1051 #
1044 1052 # def run(self, dataOut, channel = 0):
1045 1053 #
1046 1054 # if not self.isConfig:
1047 1055 # nSamples = dataOut.nHeights
1048 1056 # nChannels = dataOut.nChannels
1049 1057 # self.setup(nSamples, nChannels)
1050 1058 # self.isConfig = True
1051 1059 #
1052 1060 # #Append new data to internal buffer
1053 1061 # for thisChannel in range(self.__nChannels):
1054 1062 # bufferByChannel = self.__bufferList[thisChannel]
1055 1063 # bufferByChannel.extend(dataOut.data[thisChannel])
1056 1064 #
1057 1065 # if self.__pulseFound:
1058 1066 # self.__startIndex -= self.__nSamples
1059 1067 #
1060 1068 # #Finding Tx Pulse
1061 1069 # if not self.__pulseFound:
1062 1070 # indexFound = self.__findTxPulse(dataOut, channel)
1063 1071 #
1064 1072 # if indexFound == None:
1065 1073 # dataOut.flagNoData = True
1066 1074 # return
1067 1075 #
1068 1076 # self.__arrayBuffer = numpy.zeros((self.__nChannels, self.__newNSamples), dtype = numpy.complex)
1069 1077 # self.__pulseFound = True
1070 1078 # self.__startIndex = indexFound
1071 1079 #
1072 1080 # #If pulse was found ...
1073 1081 # for thisChannel in range(self.__nChannels):
1074 1082 # bufferByChannel = self.__bufferList[thisChannel]
1075 1083 # #print self.__startIndex
1076 1084 # x = numpy.array(bufferByChannel)
1077 1085 # self.__arrayBuffer[thisChannel] = x[self.__startIndex:self.__startIndex+self.__newNSamples]
1078 1086 #
1079 1087 # deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1080 1088 # dataOut.heightList = numpy.arange(self.__newNSamples)*deltaHeight
1081 1089 # # dataOut.ippSeconds = (self.__newNSamples / deltaHeight)/1e6
1082 1090 #
1083 1091 # dataOut.data = self.__arrayBuffer
1084 1092 #
1085 1093 # self.__startIndex += self.__newNSamples
1086 1094 #
1087 1095 # return No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,38 +1,38
1 1 '''
2 2 Created on Jul 16, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 6
7 7 from schainpy import __version__
8 8 from setuptools import setup, Extension
9 9
10 10 setup(name="schainpy",
11 11 version=__version__,
12 12 description="Python tools to read, write and process Jicamarca data",
13 13 author="Miguel Urco",
14 14 author_email="miguel.urco@jro.igp.gob.pe",
15 15 url="http://jro.igp.gob.pe",
16 16 packages = {'schainpy',
17 17 'schainpy.model',
18 18 'schainpy.model.data',
19 19 'schainpy.model.graphics',
20 20 'schainpy.model.io',
21 21 'schainpy.model.proc',
22 22 'schainpy.model.utils',
23 23 'schainpy.gui',
24 24 'schainpy.gui.figures',
25 25 'schainpy.gui.viewcontroller',
26 26 'schainpy.gui.viewer',
27 27 'schainpy.gui.viewer.windows'},
28 28 py_modules=['schainpy.serializer.DataTranslate',
29 29 'schainpy.serializer.JROSerializer'],
30 package_data={'schainpy.gui.figures': ['*.jpg', '*.jpeg', '*.png', '*.gif']},
30 package_data={'schainpy.gui.figures': ['*.png']},
31 31 include_package_data=True,
32 32 scripts =['schainpy/gui/schainGUI'],
33 33 install_requires=["numpy >= 1.6.0",
34 "scipy >= 0.11.0",
34 "scipy >= 0.9.0",
35 35 "h5py >= 2.0.1",
36 36 "matplotlib >= 1.0.0"
37 37 ],
38 38 ) No newline at end of file
Show file before | Show file after | Hide comments
1 NO CONTENT: file was removed
General Comments 0
You need to be logged in to leave comments. Login now