##// END OF EJS Templates
schain
RSS
El envio de los archivos de imagen al servidor FTP se realiza mediante un thread. Por ahora esta funcion se ha aplicado a la clase SpectraPlot
Daniel Valdez -
r435:b0b43c068e6e
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,537 +1,592
1 import os
1 import os
2 import numpy
2 import numpy
3 import time, datetime
3 import time, datetime
4 import mpldriver
4 import mpldriver
5 from customftp import *
5 from customftp import *
6
6
7 import Queue
8 import threading
9
10 class FTP_Thread (threading.Thread):
11 def __init__(self):
12 threading.Thread.__init__(self)
13 self.exitFlag = 0
14 self.queueLock = threading.Lock()
15 self.workQueue = Queue.Queue()
16
17 def run(self):
18 self.send_data()
19
20 def fin(self):
21 self.exitFlag = 1
22
23 def put_data(self, data):
24 # Fill the queue
25 self.queueLock.acquire()
26 self.workQueue.put(data)
27 self.queueLock.release()
28
29 def send_data(self):
30 while not self.exitFlag:
31 if self.workQueue.qsize():
32
33 data = self.workQueue.get(True)
34
35 try:
36 ftpObj = Ftp(host=data['server'],
37 username=data['username'],
38 passw=data['password'],
39 remotefolder=data['folder'])
40
41 ftpObj.upload(data['figfilename'])
42 ftpObj.close()
43 except:
44 print ValueError, 'Error FTP'
45 print "don't worry still running the program"
46
47
7 class Figure:
48 class Figure:
8
49
9 __driver = mpldriver
50 __driver = mpldriver
51 __isConfigThread = False
10 fig = None
52 fig = None
11
53
12 id = None
54 id = None
13 wintitle = None
55 wintitle = None
14 width = None
56 width = None
15 height = None
57 height = None
16 nplots = None
58 nplots = None
17 timerange = None
59 timerange = None
18
60
19 axesObjList = []
61 axesObjList = []
20
62
21 WIDTH = None
63 WIDTH = None
22 HEIGHT = None
64 HEIGHT = None
23 PREFIX = 'fig'
65 PREFIX = 'fig'
24
66
25 def __init__(self):
67 def __init__(self):
26
68
27 raise ValueError, "This method is not implemented"
69 raise ValueError, "This method is not implemented"
28
70
29 def __del__(self):
71 def __del__(self):
30
72
31 self.__driver.closeFigure()
73 self.__driver.closeFigure()
32
74
33 def getFilename(self, name, ext='.png'):
75 def getFilename(self, name, ext='.png'):
34
76
35 path = '%s%03d' %(self.PREFIX, self.id)
77 path = '%s%03d' %(self.PREFIX, self.id)
36 filename = '%s_%s%s' %(self.PREFIX, name, ext)
78 filename = '%s_%s%s' %(self.PREFIX, name, ext)
37 return os.path.join(path, filename)
79 return os.path.join(path, filename)
38
80
39 def getAxesObjList(self):
81 def getAxesObjList(self):
40
82
41 return self.axesObjList
83 return self.axesObjList
42
84
43 def getSubplots(self):
85 def getSubplots(self):
44
86
45 raise ValueError, "Abstract method: This method should be defined"
87 raise ValueError, "Abstract method: This method should be defined"
46
88
47 def getScreenDim(self, widthplot, heightplot):
89 def getScreenDim(self, widthplot, heightplot):
48
90
49 nrow, ncol = self.getSubplots()
91 nrow, ncol = self.getSubplots()
50
92
51 widthscreen = widthplot*ncol
93 widthscreen = widthplot*ncol
52 heightscreen = heightplot*nrow
94 heightscreen = heightplot*nrow
53
95
54 return widthscreen, heightscreen
96 return widthscreen, heightscreen
55
97
56 def getTimeLim(self, x, xmin, xmax):
98 def getTimeLim(self, x, xmin, xmax):
57
99
58 if self.timerange != None:
100 if self.timerange != None:
59 txmin = x[0] - x[0]%self.timerange
101 txmin = x[0] - x[0]%self.timerange
60 else:
102 else:
61 txmin = numpy.min(x)
103 txmin = numpy.min(x)
62
104
63 thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
105 thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
64 thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
106 thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
65
107
66 ####################################################
108 ####################################################
67 #If the x is out of xrange
109 #If the x is out of xrange
68 if xmax != None:
110 if xmax != None:
69 if xmax < (thisdatetime - thisdate).seconds/(60*60.):
111 if xmax < (thisdatetime - thisdate).seconds/(60*60.):
70 xmin = None
112 xmin = None
71 xmax = None
113 xmax = None
72
114
73 if xmin == None:
115 if xmin == None:
74 td = thisdatetime - thisdate
116 td = thisdatetime - thisdate
75 xmin = td.seconds/(60*60.)
117 xmin = td.seconds/(60*60.)
76
118
77 if xmax == None:
119 if xmax == None:
78 xmax = xmin + self.timerange/(60*60.)
120 xmax = xmin + self.timerange/(60*60.)
79
121
80 mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
122 mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
81 tmin = time.mktime(mindt.timetuple())
123 tmin = time.mktime(mindt.timetuple())
82
124
83 maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
125 maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
84 tmax = time.mktime(maxdt.timetuple())
126 tmax = time.mktime(maxdt.timetuple())
85
127
86 self.timerange = tmax - tmin
128 self.timerange = tmax - tmin
87
129
88 return tmin, tmax
130 return tmin, tmax
89
131
90 def init(self, id, nplots, wintitle):
132 def init(self, id, nplots, wintitle):
91
133
92 raise ValueError, "This method has been replaced with createFigure"
134 raise ValueError, "This method has been replaced with createFigure"
93
135
94 def createFigure(self, id, wintitle, widthplot=None, heightplot=None, show=True):
136 def createFigure(self, id, wintitle, widthplot=None, heightplot=None, show=True):
95
137
96 """
138 """
97 Crea la figura de acuerdo al driver y parametros seleccionados seleccionados.
139 Crea la figura de acuerdo al driver y parametros seleccionados seleccionados.
98 Las dimensiones de la pantalla es calculada a partir de los atributos self.WIDTH
140 Las dimensiones de la pantalla es calculada a partir de los atributos self.WIDTH
99 y self.HEIGHT y el numero de subplots (nrow, ncol)
141 y self.HEIGHT y el numero de subplots (nrow, ncol)
100
142
101 Input:
143 Input:
102 id : Los parametros necesarios son
144 id : Los parametros necesarios son
103 wintitle :
145 wintitle :
104
146
105 """
147 """
106
148
107 if widthplot == None:
149 if widthplot == None:
108 widthplot = self.WIDTH
150 widthplot = self.WIDTH
109
151
110 if heightplot == None:
152 if heightplot == None:
111 heightplot = self.HEIGHT
153 heightplot = self.HEIGHT
112
154
113 self.id = id
155 self.id = id
114
156
115 self.wintitle = wintitle
157 self.wintitle = wintitle
116
158
117 self.widthscreen, self.heightscreen = self.getScreenDim(widthplot, heightplot)
159 self.widthscreen, self.heightscreen = self.getScreenDim(widthplot, heightplot)
118
160
119 self.fig = self.__driver.createFigure(id=self.id,
161 self.fig = self.__driver.createFigure(id=self.id,
120 wintitle=self.wintitle,
162 wintitle=self.wintitle,
121 width=self.widthscreen,
163 width=self.widthscreen,
122 height=self.heightscreen,
164 height=self.heightscreen,
123 show=show)
165 show=show)
124
166
125 self.axesObjList = []
167 self.axesObjList = []
126
168
127
169
128 def setDriver(self, driver=mpldriver):
170 def setDriver(self, driver=mpldriver):
129
171
130 self.__driver = driver
172 self.__driver = driver
131
173
132 def setTitle(self, title):
174 def setTitle(self, title):
133
175
134 self.__driver.setTitle(self.fig, title)
176 self.__driver.setTitle(self.fig, title)
135
177
136 def setWinTitle(self, title):
178 def setWinTitle(self, title):
137
179
138 self.__driver.setWinTitle(self.fig, title=title)
180 self.__driver.setWinTitle(self.fig, title=title)
139
181
140 def setTextFromAxes(self, text):
182 def setTextFromAxes(self, text):
141
183
142 raise ValueError, "Este metodo ha sido reemplazaado con el metodo setText de la clase Axes"
184 raise ValueError, "Este metodo ha sido reemplazaado con el metodo setText de la clase Axes"
143
185
144 def makeAxes(self, nrow, ncol, xpos, ypos, colspan, rowspan):
186 def makeAxes(self, nrow, ncol, xpos, ypos, colspan, rowspan):
145
187
146 raise ValueError, "Este metodo ha sido reemplazaado con el metodo addAxes"
188 raise ValueError, "Este metodo ha sido reemplazaado con el metodo addAxes"
147
189
148 def addAxes(self, *args):
190 def addAxes(self, *args):
149 """
191 """
150
192
151 Input:
193 Input:
152 *args : Los parametros necesarios son
194 *args : Los parametros necesarios son
153 nrow, ncol, xpos, ypos, colspan, rowspan
195 nrow, ncol, xpos, ypos, colspan, rowspan
154 """
196 """
155
197
156 axesObj = Axes(self.fig, *args)
198 axesObj = Axes(self.fig, *args)
157 self.axesObjList.append(axesObj)
199 self.axesObjList.append(axesObj)
158
200
159 def saveFigure(self, figpath, figfile, *args):
201 def saveFigure(self, figpath, figfile, *args):
160
202
161 filename = os.path.join(figpath, figfile)
203 filename = os.path.join(figpath, figfile)
162
204
163 fullpath = os.path.split(filename)[0]
205 fullpath = os.path.split(filename)[0]
164
206
165 if not os.path.exists(fullpath):
207 if not os.path.exists(fullpath):
166 subpath = os.path.split(fullpath)[0]
208 subpath = os.path.split(fullpath)[0]
167
209
168 if not os.path.exists(subpath):
210 if not os.path.exists(subpath):
169 os.mkdir(subpath)
211 os.mkdir(subpath)
170
212
171 os.mkdir(fullpath)
213 os.mkdir(fullpath)
172
214
173 self.__driver.saveFigure(self.fig, filename, *args)
215 self.__driver.saveFigure(self.fig, filename, *args)
174
216
175 def sendByFTP(self, figfilename, server, folder, username, password):
217 def sendByFTP(self, figfilename, server, folder, username, password):
176 ftpObj = Ftp(host=server, username=username, passw=password, remotefolder=folder)
218 ftpObj = Ftp(host=server, username=username, passw=password, remotefolder=folder)
177 ftpObj.upload(figfilename)
219 ftpObj.upload(figfilename)
178 ftpObj.close()
220 ftpObj.close()
179
221
222 def sendByFTP_Thread(self, figfilename, server, folder, username, password):
223 data = {'figfilename':figfilename,'server':server,'folder':folder,'username':username,'password':password}
224
225 if not(self.__isConfigThread):
226
227 self.thread = FTP_Thread()
228 self.thread.start()
229 self.__isConfigThread = True
230
231 self.thread.put_data(data)
232 print 'thread.isAlive()', self.thread.isAlive()
233
234
180 def getNameToFtp(self, thisDatetime, FTP_WEI, EXP_CODE, SUB_EXP_CODE, PLOT_CODE, PLOT_POS):
235 def getNameToFtp(self, thisDatetime, FTP_WEI, EXP_CODE, SUB_EXP_CODE, PLOT_CODE, PLOT_POS):
181 YEAR_STR = '%4.4d'%thisDatetime.timetuple().tm_year
236 YEAR_STR = '%4.4d'%thisDatetime.timetuple().tm_year
182 DOY_STR = '%3.3d'%thisDatetime.timetuple().tm_yday
237 DOY_STR = '%3.3d'%thisDatetime.timetuple().tm_yday
183 FTP_WEI = '%2.2d'%FTP_WEI
238 FTP_WEI = '%2.2d'%FTP_WEI
184 EXP_CODE = '%3.3d'%EXP_CODE
239 EXP_CODE = '%3.3d'%EXP_CODE
185 SUB_EXP_CODE = '%2.2d'%SUB_EXP_CODE
240 SUB_EXP_CODE = '%2.2d'%SUB_EXP_CODE
186 PLOT_CODE = '%2.2d'%PLOT_CODE
241 PLOT_CODE = '%2.2d'%PLOT_CODE
187 PLOT_POS = '%2.2d'%PLOT_POS
242 PLOT_POS = '%2.2d'%PLOT_POS
188 name = YEAR_STR + DOY_STR + FTP_WEI + EXP_CODE + SUB_EXP_CODE + PLOT_CODE + PLOT_POS
243 name = YEAR_STR + DOY_STR + FTP_WEI + EXP_CODE + SUB_EXP_CODE + PLOT_CODE + PLOT_POS
189 return name
244 return name
190
245
191 def draw(self):
246 def draw(self):
192
247
193 self.__driver.draw(self.fig)
248 self.__driver.draw(self.fig)
194
249
195 def run(self):
250 def run(self):
196
251
197 raise ValueError, "This method is not implemented"
252 raise ValueError, "This method is not implemented"
198
253
199 axesList = property(getAxesObjList)
254 axesList = property(getAxesObjList)
200
255
201
256
202 class Axes:
257 class Axes:
203
258
204 __driver = mpldriver
259 __driver = mpldriver
205 fig = None
260 fig = None
206 ax = None
261 ax = None
207 plot = None
262 plot = None
208 __missing = 1E30
263 __missing = 1E30
209 __firsttime = None
264 __firsttime = None
210
265
211 __showprofile = False
266 __showprofile = False
212
267
213 xmin = None
268 xmin = None
214 xmax = None
269 xmax = None
215 ymin = None
270 ymin = None
216 ymax = None
271 ymax = None
217 zmin = None
272 zmin = None
218 zmax = None
273 zmax = None
219
274
220 x_buffer = None
275 x_buffer = None
221 z_buffer = None
276 z_buffer = None
222
277
223 decimationx = None
278 decimationx = None
224 decimationy = None
279 decimationy = None
225
280
226 __MAXNUMX = 1000
281 __MAXNUMX = 1000
227 __MAXNUMY = 500
282 __MAXNUMY = 500
228
283
229 def __init__(self, *args):
284 def __init__(self, *args):
230
285
231 """
286 """
232
287
233 Input:
288 Input:
234 *args : Los parametros necesarios son
289 *args : Los parametros necesarios son
235 fig, nrow, ncol, xpos, ypos, colspan, rowspan
290 fig, nrow, ncol, xpos, ypos, colspan, rowspan
236 """
291 """
237
292
238 ax = self.__driver.createAxes(*args)
293 ax = self.__driver.createAxes(*args)
239 self.fig = args[0]
294 self.fig = args[0]
240 self.ax = ax
295 self.ax = ax
241 self.plot = None
296 self.plot = None
242
297
243 self.__firsttime = True
298 self.__firsttime = True
244 self.idlineList = []
299 self.idlineList = []
245
300
246 self.x_buffer = numpy.array([])
301 self.x_buffer = numpy.array([])
247 self.z_buffer = numpy.array([])
302 self.z_buffer = numpy.array([])
248
303
249 def setText(self, text):
304 def setText(self, text):
250
305
251 self.__driver.setAxesText(self.ax, text)
306 self.__driver.setAxesText(self.ax, text)
252
307
253 def setXAxisAsTime(self):
308 def setXAxisAsTime(self):
254 pass
309 pass
255
310
256 def pline(self, x, y,
311 def pline(self, x, y,
257 xmin=None, xmax=None,
312 xmin=None, xmax=None,
258 ymin=None, ymax=None,
313 ymin=None, ymax=None,
259 xlabel='', ylabel='',
314 xlabel='', ylabel='',
260 title='',
315 title='',
261 **kwargs):
316 **kwargs):
262
317
263 """
318 """
264
319
265 Input:
320 Input:
266 x :
321 x :
267 y :
322 y :
268 xmin :
323 xmin :
269 xmax :
324 xmax :
270 ymin :
325 ymin :
271 ymax :
326 ymax :
272 xlabel :
327 xlabel :
273 ylabel :
328 ylabel :
274 title :
329 title :
275 **kwargs : Los parametros aceptados son
330 **kwargs : Los parametros aceptados son
276
331
277 ticksize
332 ticksize
278 ytick_visible
333 ytick_visible
279 """
334 """
280
335
281 if self.__firsttime:
336 if self.__firsttime:
282
337
283 if xmin == None: xmin = numpy.nanmin(x)
338 if xmin == None: xmin = numpy.nanmin(x)
284 if xmax == None: xmax = numpy.nanmax(x)
339 if xmax == None: xmax = numpy.nanmax(x)
285 if ymin == None: ymin = numpy.nanmin(y)
340 if ymin == None: ymin = numpy.nanmin(y)
286 if ymax == None: ymax = numpy.nanmax(y)
341 if ymax == None: ymax = numpy.nanmax(y)
287
342
288 self.plot = self.__driver.createPline(self.ax, x, y,
343 self.plot = self.__driver.createPline(self.ax, x, y,
289 xmin, xmax,
344 xmin, xmax,
290 ymin, ymax,
345 ymin, ymax,
291 xlabel=xlabel,
346 xlabel=xlabel,
292 ylabel=ylabel,
347 ylabel=ylabel,
293 title=title,
348 title=title,
294 **kwargs)
349 **kwargs)
295
350
296 self.idlineList.append(0)
351 self.idlineList.append(0)
297 self.__firsttime = False
352 self.__firsttime = False
298 return
353 return
299
354
300 self.__driver.pline(self.plot, x, y, xlabel=xlabel,
355 self.__driver.pline(self.plot, x, y, xlabel=xlabel,
301 ylabel=ylabel,
356 ylabel=ylabel,
302 title=title)
357 title=title)
303
358
304 def addpline(self, x, y, idline, **kwargs):
359 def addpline(self, x, y, idline, **kwargs):
305 lines = self.ax.lines
360 lines = self.ax.lines
306
361
307 if idline in self.idlineList:
362 if idline in self.idlineList:
308 self.__driver.set_linedata(self.ax, x, y, idline)
363 self.__driver.set_linedata(self.ax, x, y, idline)
309
364
310 if idline not in(self.idlineList):
365 if idline not in(self.idlineList):
311 self.__driver.addpline(self.ax, x, y, **kwargs)
366 self.__driver.addpline(self.ax, x, y, **kwargs)
312 self.idlineList.append(idline)
367 self.idlineList.append(idline)
313
368
314 return
369 return
315
370
316 def pmultiline(self, x, y,
371 def pmultiline(self, x, y,
317 xmin=None, xmax=None,
372 xmin=None, xmax=None,
318 ymin=None, ymax=None,
373 ymin=None, ymax=None,
319 xlabel='', ylabel='',
374 xlabel='', ylabel='',
320 title='',
375 title='',
321 **kwargs):
376 **kwargs):
322
377
323 if self.__firsttime:
378 if self.__firsttime:
324
379
325 if xmin == None: xmin = numpy.nanmin(x)
380 if xmin == None: xmin = numpy.nanmin(x)
326 if xmax == None: xmax = numpy.nanmax(x)
381 if xmax == None: xmax = numpy.nanmax(x)
327 if ymin == None: ymin = numpy.nanmin(y)
382 if ymin == None: ymin = numpy.nanmin(y)
328 if ymax == None: ymax = numpy.nanmax(y)
383 if ymax == None: ymax = numpy.nanmax(y)
329
384
330 self.plot = self.__driver.createPmultiline(self.ax, x, y,
385 self.plot = self.__driver.createPmultiline(self.ax, x, y,
331 xmin, xmax,
386 xmin, xmax,
332 ymin, ymax,
387 ymin, ymax,
333 xlabel=xlabel,
388 xlabel=xlabel,
334 ylabel=ylabel,
389 ylabel=ylabel,
335 title=title,
390 title=title,
336 **kwargs)
391 **kwargs)
337 self.__firsttime = False
392 self.__firsttime = False
338 return
393 return
339
394
340 self.__driver.pmultiline(self.plot, x, y, xlabel=xlabel,
395 self.__driver.pmultiline(self.plot, x, y, xlabel=xlabel,
341 ylabel=ylabel,
396 ylabel=ylabel,
342 title=title)
397 title=title)
343
398
344 def pmultilineyaxis(self, x, y,
399 def pmultilineyaxis(self, x, y,
345 xmin=None, xmax=None,
400 xmin=None, xmax=None,
346 ymin=None, ymax=None,
401 ymin=None, ymax=None,
347 xlabel='', ylabel='',
402 xlabel='', ylabel='',
348 title='',
403 title='',
349 **kwargs):
404 **kwargs):
350
405
351 if self.__firsttime:
406 if self.__firsttime:
352
407
353 if xmin == None: xmin = numpy.nanmin(x)
408 if xmin == None: xmin = numpy.nanmin(x)
354 if xmax == None: xmax = numpy.nanmax(x)
409 if xmax == None: xmax = numpy.nanmax(x)
355 if ymin == None: ymin = numpy.nanmin(y)
410 if ymin == None: ymin = numpy.nanmin(y)
356 if ymax == None: ymax = numpy.nanmax(y)
411 if ymax == None: ymax = numpy.nanmax(y)
357
412
358 self.plot = self.__driver.createPmultilineYAxis(self.ax, x, y,
413 self.plot = self.__driver.createPmultilineYAxis(self.ax, x, y,
359 xmin, xmax,
414 xmin, xmax,
360 ymin, ymax,
415 ymin, ymax,
361 xlabel=xlabel,
416 xlabel=xlabel,
362 ylabel=ylabel,
417 ylabel=ylabel,
363 title=title,
418 title=title,
364 **kwargs)
419 **kwargs)
365 if self.xmin == None: self.xmin = xmin
420 if self.xmin == None: self.xmin = xmin
366 if self.xmax == None: self.xmax = xmax
421 if self.xmax == None: self.xmax = xmax
367 if self.ymin == None: self.ymin = ymin
422 if self.ymin == None: self.ymin = ymin
368 if self.ymax == None: self.ymax = ymax
423 if self.ymax == None: self.ymax = ymax
369
424
370 self.__firsttime = False
425 self.__firsttime = False
371 return
426 return
372
427
373 self.__driver.pmultilineyaxis(self.plot, x, y, xlabel=xlabel,
428 self.__driver.pmultilineyaxis(self.plot, x, y, xlabel=xlabel,
374 ylabel=ylabel,
429 ylabel=ylabel,
375 title=title)
430 title=title)
376
431
377 def pcolor(self, x, y, z,
432 def pcolor(self, x, y, z,
378 xmin=None, xmax=None,
433 xmin=None, xmax=None,
379 ymin=None, ymax=None,
434 ymin=None, ymax=None,
380 zmin=None, zmax=None,
435 zmin=None, zmax=None,
381 xlabel='', ylabel='',
436 xlabel='', ylabel='',
382 title='', rti = False, colormap='jet',
437 title='', rti = False, colormap='jet',
383 **kwargs):
438 **kwargs):
384
439
385 """
440 """
386 Input:
441 Input:
387 x :
442 x :
388 y :
443 y :
389 x :
444 x :
390 xmin :
445 xmin :
391 xmax :
446 xmax :
392 ymin :
447 ymin :
393 ymax :
448 ymax :
394 zmin :
449 zmin :
395 zmax :
450 zmax :
396 xlabel :
451 xlabel :
397 ylabel :
452 ylabel :
398 title :
453 title :
399 **kwargs : Los parametros aceptados son
454 **kwargs : Los parametros aceptados son
400 ticksize=9,
455 ticksize=9,
401 cblabel=''
456 cblabel=''
402 rti = True or False
457 rti = True or False
403 """
458 """
404
459
405 if self.__firsttime:
460 if self.__firsttime:
406
461
407 if xmin == None: xmin = numpy.nanmin(x)
462 if xmin == None: xmin = numpy.nanmin(x)
408 if xmax == None: xmax = numpy.nanmax(x)
463 if xmax == None: xmax = numpy.nanmax(x)
409 if ymin == None: ymin = numpy.nanmin(y)
464 if ymin == None: ymin = numpy.nanmin(y)
410 if ymax == None: ymax = numpy.nanmax(y)
465 if ymax == None: ymax = numpy.nanmax(y)
411 if zmin == None: zmin = numpy.nanmin(z)
466 if zmin == None: zmin = numpy.nanmin(z)
412 if zmax == None: zmax = numpy.nanmax(z)
467 if zmax == None: zmax = numpy.nanmax(z)
413
468
414
469
415 self.plot = self.__driver.createPcolor(self.ax, x, y, z,
470 self.plot = self.__driver.createPcolor(self.ax, x, y, z,
416 xmin, xmax,
471 xmin, xmax,
417 ymin, ymax,
472 ymin, ymax,
418 zmin, zmax,
473 zmin, zmax,
419 xlabel=xlabel,
474 xlabel=xlabel,
420 ylabel=ylabel,
475 ylabel=ylabel,
421 title=title,
476 title=title,
422 colormap=colormap,
477 colormap=colormap,
423 **kwargs)
478 **kwargs)
424
479
425 if self.xmin == None: self.xmin = xmin
480 if self.xmin == None: self.xmin = xmin
426 if self.xmax == None: self.xmax = xmax
481 if self.xmax == None: self.xmax = xmax
427 if self.ymin == None: self.ymin = ymin
482 if self.ymin == None: self.ymin = ymin
428 if self.ymax == None: self.ymax = ymax
483 if self.ymax == None: self.ymax = ymax
429 if self.zmin == None: self.zmin = zmin
484 if self.zmin == None: self.zmin = zmin
430 if self.zmax == None: self.zmax = zmax
485 if self.zmax == None: self.zmax = zmax
431
486
432 self.__firsttime = False
487 self.__firsttime = False
433 return
488 return
434
489
435 if rti:
490 if rti:
436 self.__driver.addpcolor(self.ax, x, y, z, self.zmin, self.zmax,
491 self.__driver.addpcolor(self.ax, x, y, z, self.zmin, self.zmax,
437 xlabel=xlabel,
492 xlabel=xlabel,
438 ylabel=ylabel,
493 ylabel=ylabel,
439 title=title,
494 title=title,
440 colormap=colormap)
495 colormap=colormap)
441 return
496 return
442
497
443 self.__driver.pcolor(self.plot, z,
498 self.__driver.pcolor(self.plot, z,
444 xlabel=xlabel,
499 xlabel=xlabel,
445 ylabel=ylabel,
500 ylabel=ylabel,
446 title=title)
501 title=title)
447
502
448 def pcolorbuffer(self, x, y, z,
503 def pcolorbuffer(self, x, y, z,
449 xmin=None, xmax=None,
504 xmin=None, xmax=None,
450 ymin=None, ymax=None,
505 ymin=None, ymax=None,
451 zmin=None, zmax=None,
506 zmin=None, zmax=None,
452 xlabel='', ylabel='',
507 xlabel='', ylabel='',
453 title='', rti = True, colormap='jet',
508 title='', rti = True, colormap='jet',
454 maxNumX = None, maxNumY = None,
509 maxNumX = None, maxNumY = None,
455 **kwargs):
510 **kwargs):
456
511
457 if maxNumX == None:
512 if maxNumX == None:
458 maxNumX = self.__MAXNUMX
513 maxNumX = self.__MAXNUMX
459
514
460 if maxNumY == None:
515 if maxNumY == None:
461 maxNumY = self.__MAXNUMY
516 maxNumY = self.__MAXNUMY
462
517
463 if self.__firsttime:
518 if self.__firsttime:
464 self.z_buffer = z
519 self.z_buffer = z
465 self.x_buffer = numpy.hstack((self.x_buffer, x))
520 self.x_buffer = numpy.hstack((self.x_buffer, x))
466
521
467 if xmin == None: xmin = numpy.nanmin(x)
522 if xmin == None: xmin = numpy.nanmin(x)
468 if xmax == None: xmax = numpy.nanmax(x)
523 if xmax == None: xmax = numpy.nanmax(x)
469 if ymin == None: ymin = numpy.nanmin(y)
524 if ymin == None: ymin = numpy.nanmin(y)
470 if ymax == None: ymax = numpy.nanmax(y)
525 if ymax == None: ymax = numpy.nanmax(y)
471 if zmin == None: zmin = numpy.nanmin(z)
526 if zmin == None: zmin = numpy.nanmin(z)
472 if zmax == None: zmax = numpy.nanmax(z)
527 if zmax == None: zmax = numpy.nanmax(z)
473
528
474
529
475 self.plot = self.__driver.createPcolor(self.ax, self.x_buffer, y, z,
530 self.plot = self.__driver.createPcolor(self.ax, self.x_buffer, y, z,
476 xmin, xmax,
531 xmin, xmax,
477 ymin, ymax,
532 ymin, ymax,
478 zmin, zmax,
533 zmin, zmax,
479 xlabel=xlabel,
534 xlabel=xlabel,
480 ylabel=ylabel,
535 ylabel=ylabel,
481 title=title,
536 title=title,
482 colormap=colormap,
537 colormap=colormap,
483 **kwargs)
538 **kwargs)
484
539
485 if self.xmin == None: self.xmin = xmin
540 if self.xmin == None: self.xmin = xmin
486 if self.xmax == None: self.xmax = xmax
541 if self.xmax == None: self.xmax = xmax
487 if self.ymin == None: self.ymin = ymin
542 if self.ymin == None: self.ymin = ymin
488 if self.ymax == None: self.ymax = ymax
543 if self.ymax == None: self.ymax = ymax
489 if self.zmin == None: self.zmin = zmin
544 if self.zmin == None: self.zmin = zmin
490 if self.zmax == None: self.zmax = zmax
545 if self.zmax == None: self.zmax = zmax
491
546
492 self.__firsttime = False
547 self.__firsttime = False
493 return
548 return
494
549
495 self.x_buffer = numpy.hstack((self.x_buffer, x[-1]))
550 self.x_buffer = numpy.hstack((self.x_buffer, x[-1]))
496 self.z_buffer = numpy.hstack((self.z_buffer, z))
551 self.z_buffer = numpy.hstack((self.z_buffer, z))
497
552
498 if self.decimationx == None:
553 if self.decimationx == None:
499 deltax = (self.xmax - self.xmin)/maxNumX
554 deltax = (self.xmax - self.xmin)/maxNumX
500 deltay = (self.ymax - self.ymin)/maxNumY
555 deltay = (self.ymax - self.ymin)/maxNumY
501
556
502 resolutionx = self.x_buffer[2]-self.x_buffer[0]
557 resolutionx = self.x_buffer[2]-self.x_buffer[0]
503 resolutiony = y[1]-y[0]
558 resolutiony = y[1]-y[0]
504
559
505 self.decimationx = numpy.ceil(deltax / resolutionx)
560 self.decimationx = numpy.ceil(deltax / resolutionx)
506 self.decimationy = numpy.ceil(deltay / resolutiony)
561 self.decimationy = numpy.ceil(deltay / resolutiony)
507
562
508 z_buffer = self.z_buffer.reshape(-1,len(y))
563 z_buffer = self.z_buffer.reshape(-1,len(y))
509
564
510 x_buffer = self.x_buffer[::self.decimationx]
565 x_buffer = self.x_buffer[::self.decimationx]
511 y_buffer = y[::self.decimationy]
566 y_buffer = y[::self.decimationy]
512 z_buffer = z_buffer[::self.decimationx, ::self.decimationy]
567 z_buffer = z_buffer[::self.decimationx, ::self.decimationy]
513 #===================================================
568 #===================================================
514
569
515 x_buffer, y_buffer, z_buffer = self.__fillGaps(x_buffer, y_buffer, z_buffer)
570 x_buffer, y_buffer, z_buffer = self.__fillGaps(x_buffer, y_buffer, z_buffer)
516
571
517 self.__driver.addpcolorbuffer(self.ax, x_buffer, y_buffer, z_buffer, self.zmin, self.zmax,
572 self.__driver.addpcolorbuffer(self.ax, x_buffer, y_buffer, z_buffer, self.zmin, self.zmax,
518 xlabel=xlabel,
573 xlabel=xlabel,
519 ylabel=ylabel,
574 ylabel=ylabel,
520 title=title,
575 title=title,
521 colormap=colormap)
576 colormap=colormap)
522 def __fillGaps(self, x_buffer, y_buffer, z_buffer):
577 def __fillGaps(self, x_buffer, y_buffer, z_buffer):
523
578
524 deltas = x_buffer[1:] - x_buffer[0:-1]
579 deltas = x_buffer[1:] - x_buffer[0:-1]
525 x_median = numpy.median(deltas)
580 x_median = numpy.median(deltas)
526
581
527 index = numpy.where(deltas >= 2*x_median)
582 index = numpy.where(deltas >= 2*x_median)
528
583
529 if len(index[0]) != 0:
584 if len(index[0]) != 0:
530 z_buffer[index[0],::] = self.__missing
585 z_buffer[index[0],::] = self.__missing
531 z_buffer = numpy.ma.masked_inside(z_buffer,0.99*self.__missing,1.01*self.__missing)
586 z_buffer = numpy.ma.masked_inside(z_buffer,0.99*self.__missing,1.01*self.__missing)
532
587
533 return x_buffer, y_buffer, z_buffer
588 return x_buffer, y_buffer, z_buffer
534
589
535
590
536
591
537 No newline at end of file
592
Show file before | Show file after | Hide comments
@@ -1,1532 +1,1530
1 import numpy
1 import numpy
2 import time, datetime, os
2 import time, datetime, os
3 from graphics.figure import *
3 from graphics.figure import *
4 def isRealtime(utcdatatime):
4 def isRealtime(utcdatatime):
5 utcnow = time.mktime(time.localtime())
5 utcnow = time.mktime(time.localtime())
6 delta = abs(utcnow - utcdatatime) # abs
6 delta = abs(utcnow - utcdatatime) # abs
7 if delta >= 30.:
7 if delta >= 30.:
8 return False
8 return False
9 return True
9 return True
10
10
11 class CrossSpectraPlot(Figure):
11 class CrossSpectraPlot(Figure):
12
12
13 __isConfig = None
13 __isConfig = None
14 __nsubplots = None
14 __nsubplots = None
15
15
16 WIDTH = None
16 WIDTH = None
17 HEIGHT = None
17 HEIGHT = None
18 WIDTHPROF = None
18 WIDTHPROF = None
19 HEIGHTPROF = None
19 HEIGHTPROF = None
20 PREFIX = 'cspc'
20 PREFIX = 'cspc'
21
21
22 def __init__(self):
22 def __init__(self):
23
23
24 self.__isConfig = False
24 self.__isConfig = False
25 self.__nsubplots = 4
25 self.__nsubplots = 4
26 self.counter_imagwr = 0
26 self.counter_imagwr = 0
27 self.WIDTH = 250
27 self.WIDTH = 250
28 self.HEIGHT = 250
28 self.HEIGHT = 250
29 self.WIDTHPROF = 0
29 self.WIDTHPROF = 0
30 self.HEIGHTPROF = 0
30 self.HEIGHTPROF = 0
31
31
32 self.PLOT_CODE = 1
32 self.PLOT_CODE = 1
33 self.FTP_WEI = None
33 self.FTP_WEI = None
34 self.EXP_CODE = None
34 self.EXP_CODE = None
35 self.SUB_EXP_CODE = None
35 self.SUB_EXP_CODE = None
36 self.PLOT_POS = None
36 self.PLOT_POS = None
37
37
38 def getSubplots(self):
38 def getSubplots(self):
39
39
40 ncol = 4
40 ncol = 4
41 nrow = self.nplots
41 nrow = self.nplots
42
42
43 return nrow, ncol
43 return nrow, ncol
44
44
45 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
45 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
46
46
47 self.__showprofile = showprofile
47 self.__showprofile = showprofile
48 self.nplots = nplots
48 self.nplots = nplots
49
49
50 ncolspan = 1
50 ncolspan = 1
51 colspan = 1
51 colspan = 1
52
52
53 self.createFigure(id = id,
53 self.createFigure(id = id,
54 wintitle = wintitle,
54 wintitle = wintitle,
55 widthplot = self.WIDTH + self.WIDTHPROF,
55 widthplot = self.WIDTH + self.WIDTHPROF,
56 heightplot = self.HEIGHT + self.HEIGHTPROF,
56 heightplot = self.HEIGHT + self.HEIGHTPROF,
57 show=True)
57 show=True)
58
58
59 nrow, ncol = self.getSubplots()
59 nrow, ncol = self.getSubplots()
60
60
61 counter = 0
61 counter = 0
62 for y in range(nrow):
62 for y in range(nrow):
63 for x in range(ncol):
63 for x in range(ncol):
64 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
64 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
65
65
66 counter += 1
66 counter += 1
67
67
68 def run(self, dataOut, id, wintitle="", pairsList=None,
68 def run(self, dataOut, id, wintitle="", pairsList=None,
69 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
69 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
70 save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
70 save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
71 power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
71 power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
72 server=None, folder=None, username=None, password=None,
72 server=None, folder=None, username=None, password=None,
73 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
73 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
74
74
75 """
75 """
76
76
77 Input:
77 Input:
78 dataOut :
78 dataOut :
79 id :
79 id :
80 wintitle :
80 wintitle :
81 channelList :
81 channelList :
82 showProfile :
82 showProfile :
83 xmin : None,
83 xmin : None,
84 xmax : None,
84 xmax : None,
85 ymin : None,
85 ymin : None,
86 ymax : None,
86 ymax : None,
87 zmin : None,
87 zmin : None,
88 zmax : None
88 zmax : None
89 """
89 """
90
90
91 if pairsList == None:
91 if pairsList == None:
92 pairsIndexList = dataOut.pairsIndexList
92 pairsIndexList = dataOut.pairsIndexList
93 else:
93 else:
94 pairsIndexList = []
94 pairsIndexList = []
95 for pair in pairsList:
95 for pair in pairsList:
96 if pair not in dataOut.pairsList:
96 if pair not in dataOut.pairsList:
97 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
97 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
98 pairsIndexList.append(dataOut.pairsList.index(pair))
98 pairsIndexList.append(dataOut.pairsList.index(pair))
99
99
100 if pairsIndexList == []:
100 if pairsIndexList == []:
101 return
101 return
102
102
103 if len(pairsIndexList) > 4:
103 if len(pairsIndexList) > 4:
104 pairsIndexList = pairsIndexList[0:4]
104 pairsIndexList = pairsIndexList[0:4]
105 factor = dataOut.normFactor
105 factor = dataOut.normFactor
106 x = dataOut.getVelRange(1)
106 x = dataOut.getVelRange(1)
107 y = dataOut.getHeiRange()
107 y = dataOut.getHeiRange()
108 z = dataOut.data_spc[:,:,:]/factor
108 z = dataOut.data_spc[:,:,:]/factor
109 # z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
109 # z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
110 avg = numpy.abs(numpy.average(z, axis=1))
110 avg = numpy.abs(numpy.average(z, axis=1))
111 noise = dataOut.getNoise()/factor
111 noise = dataOut.getNoise()/factor
112
112
113 zdB = 10*numpy.log10(z)
113 zdB = 10*numpy.log10(z)
114 avgdB = 10*numpy.log10(avg)
114 avgdB = 10*numpy.log10(avg)
115 noisedB = 10*numpy.log10(noise)
115 noisedB = 10*numpy.log10(noise)
116
116
117
117
118 #thisDatetime = dataOut.datatime
118 #thisDatetime = dataOut.datatime
119 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
119 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
120 title = wintitle + " Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
120 title = wintitle + " Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
121 xlabel = "Velocity (m/s)"
121 xlabel = "Velocity (m/s)"
122 ylabel = "Range (Km)"
122 ylabel = "Range (Km)"
123
123
124 if not self.__isConfig:
124 if not self.__isConfig:
125
125
126 nplots = len(pairsIndexList)
126 nplots = len(pairsIndexList)
127
127
128 self.setup(id=id,
128 self.setup(id=id,
129 nplots=nplots,
129 nplots=nplots,
130 wintitle=wintitle,
130 wintitle=wintitle,
131 showprofile=False,
131 showprofile=False,
132 show=show)
132 show=show)
133
133
134 if xmin == None: xmin = numpy.nanmin(x)
134 if xmin == None: xmin = numpy.nanmin(x)
135 if xmax == None: xmax = numpy.nanmax(x)
135 if xmax == None: xmax = numpy.nanmax(x)
136 if ymin == None: ymin = numpy.nanmin(y)
136 if ymin == None: ymin = numpy.nanmin(y)
137 if ymax == None: ymax = numpy.nanmax(y)
137 if ymax == None: ymax = numpy.nanmax(y)
138 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
138 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
139 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
139 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
140
140
141 self.FTP_WEI = ftp_wei
141 self.FTP_WEI = ftp_wei
142 self.EXP_CODE = exp_code
142 self.EXP_CODE = exp_code
143 self.SUB_EXP_CODE = sub_exp_code
143 self.SUB_EXP_CODE = sub_exp_code
144 self.PLOT_POS = plot_pos
144 self.PLOT_POS = plot_pos
145
145
146 self.__isConfig = True
146 self.__isConfig = True
147
147
148 self.setWinTitle(title)
148 self.setWinTitle(title)
149
149
150 for i in range(self.nplots):
150 for i in range(self.nplots):
151 pair = dataOut.pairsList[pairsIndexList[i]]
151 pair = dataOut.pairsList[pairsIndexList[i]]
152 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
152 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
153 title = "Ch%d: %4.2fdB: %s" %(pair[0], noisedB[pair[0]], str_datetime)
153 title = "Ch%d: %4.2fdB: %s" %(pair[0], noisedB[pair[0]], str_datetime)
154 zdB = 10.*numpy.log10(dataOut.data_spc[pair[0],:,:]/factor)
154 zdB = 10.*numpy.log10(dataOut.data_spc[pair[0],:,:]/factor)
155 axes0 = self.axesList[i*self.__nsubplots]
155 axes0 = self.axesList[i*self.__nsubplots]
156 axes0.pcolor(x, y, zdB,
156 axes0.pcolor(x, y, zdB,
157 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
157 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
158 xlabel=xlabel, ylabel=ylabel, title=title,
158 xlabel=xlabel, ylabel=ylabel, title=title,
159 ticksize=9, colormap=power_cmap, cblabel='')
159 ticksize=9, colormap=power_cmap, cblabel='')
160
160
161 title = "Ch%d: %4.2fdB: %s" %(pair[1], noisedB[pair[1]], str_datetime)
161 title = "Ch%d: %4.2fdB: %s" %(pair[1], noisedB[pair[1]], str_datetime)
162 zdB = 10.*numpy.log10(dataOut.data_spc[pair[1],:,:]/factor)
162 zdB = 10.*numpy.log10(dataOut.data_spc[pair[1],:,:]/factor)
163 axes0 = self.axesList[i*self.__nsubplots+1]
163 axes0 = self.axesList[i*self.__nsubplots+1]
164 axes0.pcolor(x, y, zdB,
164 axes0.pcolor(x, y, zdB,
165 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
165 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
166 xlabel=xlabel, ylabel=ylabel, title=title,
166 xlabel=xlabel, ylabel=ylabel, title=title,
167 ticksize=9, colormap=power_cmap, cblabel='')
167 ticksize=9, colormap=power_cmap, cblabel='')
168
168
169 coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
169 coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
170 coherence = numpy.abs(coherenceComplex)
170 coherence = numpy.abs(coherenceComplex)
171 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
171 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
172 phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
172 phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
173
173
174 title = "Coherence %d%d" %(pair[0], pair[1])
174 title = "Coherence %d%d" %(pair[0], pair[1])
175 axes0 = self.axesList[i*self.__nsubplots+2]
175 axes0 = self.axesList[i*self.__nsubplots+2]
176 axes0.pcolor(x, y, coherence,
176 axes0.pcolor(x, y, coherence,
177 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
177 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
178 xlabel=xlabel, ylabel=ylabel, title=title,
178 xlabel=xlabel, ylabel=ylabel, title=title,
179 ticksize=9, colormap=coherence_cmap, cblabel='')
179 ticksize=9, colormap=coherence_cmap, cblabel='')
180
180
181 title = "Phase %d%d" %(pair[0], pair[1])
181 title = "Phase %d%d" %(pair[0], pair[1])
182 axes0 = self.axesList[i*self.__nsubplots+3]
182 axes0 = self.axesList[i*self.__nsubplots+3]
183 axes0.pcolor(x, y, phase,
183 axes0.pcolor(x, y, phase,
184 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
184 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
185 xlabel=xlabel, ylabel=ylabel, title=title,
185 xlabel=xlabel, ylabel=ylabel, title=title,
186 ticksize=9, colormap=phase_cmap, cblabel='')
186 ticksize=9, colormap=phase_cmap, cblabel='')
187
187
188
188
189
189
190 self.draw()
190 self.draw()
191
191
192 if save:
192 if save:
193
193
194 self.counter_imagwr += 1
194 self.counter_imagwr += 1
195 if (self.counter_imagwr==wr_period):
195 if (self.counter_imagwr==wr_period):
196 if figfile == None:
196 if figfile == None:
197 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
197 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
198 figfile = self.getFilename(name = str_datetime)
198 figfile = self.getFilename(name = str_datetime)
199
199
200 self.saveFigure(figpath, figfile)
200 self.saveFigure(figpath, figfile)
201
201
202 if ftp:
202 if ftp:
203 #provisionalmente envia archivos en el formato de la web en tiempo real
203 #provisionalmente envia archivos en el formato de la web en tiempo real
204 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
204 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
205 path = '%s%03d' %(self.PREFIX, self.id)
205 path = '%s%03d' %(self.PREFIX, self.id)
206 ftp_file = os.path.join(path,'ftp','%s.png'%name)
206 ftp_file = os.path.join(path,'ftp','%s.png'%name)
207 self.saveFigure(figpath, ftp_file)
207 self.saveFigure(figpath, ftp_file)
208 ftp_filename = os.path.join(figpath,ftp_file)
208 ftp_filename = os.path.join(figpath,ftp_file)
209
209
210 try:
210 try:
211 self.sendByFTP(ftp_filename, server, folder, username, password)
211 self.sendByFTP(ftp_filename, server, folder, username, password)
212 except:
212 except:
213 self.counter_imagwr = 0
213 self.counter_imagwr = 0
214 print ValueError, 'Error FTP'
214 print ValueError, 'Error FTP'
215
215
216 self.counter_imagwr = 0
216 self.counter_imagwr = 0
217
217
218
218
219 class RTIPlot(Figure):
219 class RTIPlot(Figure):
220
220
221 __isConfig = None
221 __isConfig = None
222 __nsubplots = None
222 __nsubplots = None
223
223
224 WIDTHPROF = None
224 WIDTHPROF = None
225 HEIGHTPROF = None
225 HEIGHTPROF = None
226 PREFIX = 'rti'
226 PREFIX = 'rti'
227
227
228 def __init__(self):
228 def __init__(self):
229
229
230 self.timerange = 2*60*60
230 self.timerange = 2*60*60
231 self.__isConfig = False
231 self.__isConfig = False
232 self.__nsubplots = 1
232 self.__nsubplots = 1
233
233
234 self.WIDTH = 800
234 self.WIDTH = 800
235 self.HEIGHT = 150
235 self.HEIGHT = 150
236 self.WIDTHPROF = 120
236 self.WIDTHPROF = 120
237 self.HEIGHTPROF = 0
237 self.HEIGHTPROF = 0
238 self.counter_imagwr = 0
238 self.counter_imagwr = 0
239
239
240 self.PLOT_CODE = 0
240 self.PLOT_CODE = 0
241 self.FTP_WEI = None
241 self.FTP_WEI = None
242 self.EXP_CODE = None
242 self.EXP_CODE = None
243 self.SUB_EXP_CODE = None
243 self.SUB_EXP_CODE = None
244 self.PLOT_POS = None
244 self.PLOT_POS = None
245
245
246 def getSubplots(self):
246 def getSubplots(self):
247
247
248 ncol = 1
248 ncol = 1
249 nrow = self.nplots
249 nrow = self.nplots
250
250
251 return nrow, ncol
251 return nrow, ncol
252
252
253 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
253 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
254
254
255 self.__showprofile = showprofile
255 self.__showprofile = showprofile
256 self.nplots = nplots
256 self.nplots = nplots
257
257
258 ncolspan = 1
258 ncolspan = 1
259 colspan = 1
259 colspan = 1
260 if showprofile:
260 if showprofile:
261 ncolspan = 7
261 ncolspan = 7
262 colspan = 6
262 colspan = 6
263 self.__nsubplots = 2
263 self.__nsubplots = 2
264
264
265 self.createFigure(id = id,
265 self.createFigure(id = id,
266 wintitle = wintitle,
266 wintitle = wintitle,
267 widthplot = self.WIDTH + self.WIDTHPROF,
267 widthplot = self.WIDTH + self.WIDTHPROF,
268 heightplot = self.HEIGHT + self.HEIGHTPROF,
268 heightplot = self.HEIGHT + self.HEIGHTPROF,
269 show=show)
269 show=show)
270
270
271 nrow, ncol = self.getSubplots()
271 nrow, ncol = self.getSubplots()
272
272
273 counter = 0
273 counter = 0
274 for y in range(nrow):
274 for y in range(nrow):
275 for x in range(ncol):
275 for x in range(ncol):
276
276
277 if counter >= self.nplots:
277 if counter >= self.nplots:
278 break
278 break
279
279
280 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
280 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
281
281
282 if showprofile:
282 if showprofile:
283 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
283 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
284
284
285 counter += 1
285 counter += 1
286
286
287 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
287 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
288 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
288 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
289 timerange=None,
289 timerange=None,
290 save=False, figpath='./', figfile=None, ftp=False, wr_period=1, show=True,
290 save=False, figpath='./', figfile=None, ftp=False, wr_period=1, show=True,
291 server=None, folder=None, username=None, password=None,
291 server=None, folder=None, username=None, password=None,
292 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
292 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
293
293
294 """
294 """
295
295
296 Input:
296 Input:
297 dataOut :
297 dataOut :
298 id :
298 id :
299 wintitle :
299 wintitle :
300 channelList :
300 channelList :
301 showProfile :
301 showProfile :
302 xmin : None,
302 xmin : None,
303 xmax : None,
303 xmax : None,
304 ymin : None,
304 ymin : None,
305 ymax : None,
305 ymax : None,
306 zmin : None,
306 zmin : None,
307 zmax : None
307 zmax : None
308 """
308 """
309
309
310 if channelList == None:
310 if channelList == None:
311 channelIndexList = dataOut.channelIndexList
311 channelIndexList = dataOut.channelIndexList
312 else:
312 else:
313 channelIndexList = []
313 channelIndexList = []
314 for channel in channelList:
314 for channel in channelList:
315 if channel not in dataOut.channelList:
315 if channel not in dataOut.channelList:
316 raise ValueError, "Channel %d is not in dataOut.channelList"
316 raise ValueError, "Channel %d is not in dataOut.channelList"
317 channelIndexList.append(dataOut.channelList.index(channel))
317 channelIndexList.append(dataOut.channelList.index(channel))
318
318
319 if timerange != None:
319 if timerange != None:
320 self.timerange = timerange
320 self.timerange = timerange
321
321
322 tmin = None
322 tmin = None
323 tmax = None
323 tmax = None
324 factor = dataOut.normFactor
324 factor = dataOut.normFactor
325 x = dataOut.getTimeRange()
325 x = dataOut.getTimeRange()
326 y = dataOut.getHeiRange()
326 y = dataOut.getHeiRange()
327
327
328 z = dataOut.data_spc[channelIndexList,:,:]/factor
328 z = dataOut.data_spc[channelIndexList,:,:]/factor
329 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
329 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
330 avg = numpy.average(z, axis=1)
330 avg = numpy.average(z, axis=1)
331
331
332 avgdB = 10.*numpy.log10(avg)
332 avgdB = 10.*numpy.log10(avg)
333
333
334
334
335 # thisDatetime = dataOut.datatime
335 # thisDatetime = dataOut.datatime
336 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
336 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
337 title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
337 title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
338 xlabel = ""
338 xlabel = ""
339 ylabel = "Range (Km)"
339 ylabel = "Range (Km)"
340
340
341 if not self.__isConfig:
341 if not self.__isConfig:
342
342
343 nplots = len(channelIndexList)
343 nplots = len(channelIndexList)
344
344
345 self.setup(id=id,
345 self.setup(id=id,
346 nplots=nplots,
346 nplots=nplots,
347 wintitle=wintitle,
347 wintitle=wintitle,
348 showprofile=showprofile,
348 showprofile=showprofile,
349 show=show)
349 show=show)
350
350
351 tmin, tmax = self.getTimeLim(x, xmin, xmax)
351 tmin, tmax = self.getTimeLim(x, xmin, xmax)
352 if ymin == None: ymin = numpy.nanmin(y)
352 if ymin == None: ymin = numpy.nanmin(y)
353 if ymax == None: ymax = numpy.nanmax(y)
353 if ymax == None: ymax = numpy.nanmax(y)
354 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
354 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
355 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
355 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
356
356
357 self.FTP_WEI = ftp_wei
357 self.FTP_WEI = ftp_wei
358 self.EXP_CODE = exp_code
358 self.EXP_CODE = exp_code
359 self.SUB_EXP_CODE = sub_exp_code
359 self.SUB_EXP_CODE = sub_exp_code
360 self.PLOT_POS = plot_pos
360 self.PLOT_POS = plot_pos
361
361
362 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
362 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
363 self.__isConfig = True
363 self.__isConfig = True
364
364
365
365
366 self.setWinTitle(title)
366 self.setWinTitle(title)
367
367
368 for i in range(self.nplots):
368 for i in range(self.nplots):
369 title = "Channel %d: %s" %(dataOut.channelList[i]+1, thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
369 title = "Channel %d: %s" %(dataOut.channelList[i]+1, thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
370 axes = self.axesList[i*self.__nsubplots]
370 axes = self.axesList[i*self.__nsubplots]
371 zdB = avgdB[i].reshape((1,-1))
371 zdB = avgdB[i].reshape((1,-1))
372 axes.pcolorbuffer(x, y, zdB,
372 axes.pcolorbuffer(x, y, zdB,
373 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
373 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
374 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
374 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
375 ticksize=9, cblabel='', cbsize="1%")
375 ticksize=9, cblabel='', cbsize="1%")
376
376
377 if self.__showprofile:
377 if self.__showprofile:
378 axes = self.axesList[i*self.__nsubplots +1]
378 axes = self.axesList[i*self.__nsubplots +1]
379 axes.pline(avgdB[i], y,
379 axes.pline(avgdB[i], y,
380 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
380 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
381 xlabel='dB', ylabel='', title='',
381 xlabel='dB', ylabel='', title='',
382 ytick_visible=False,
382 ytick_visible=False,
383 grid='x')
383 grid='x')
384
384
385 self.draw()
385 self.draw()
386
386
387 if save:
387 if save:
388
388
389 self.counter_imagwr += 1
389 self.counter_imagwr += 1
390 if (self.counter_imagwr==wr_period):
390 if (self.counter_imagwr==wr_period):
391 if figfile == None:
391 if figfile == None:
392 figfile = self.getFilename(name = self.name)
392 figfile = self.getFilename(name = self.name)
393 self.saveFigure(figpath, figfile)
393 self.saveFigure(figpath, figfile)
394
394
395 if ftp:
395 if ftp:
396 #provisionalmente envia archivos en el formato de la web en tiempo real
396 #provisionalmente envia archivos en el formato de la web en tiempo real
397 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
397 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
398 path = '%s%03d' %(self.PREFIX, self.id)
398 path = '%s%03d' %(self.PREFIX, self.id)
399 ftp_file = os.path.join(path,'ftp','%s.png'%name)
399 ftp_file = os.path.join(path,'ftp','%s.png'%name)
400 self.saveFigure(figpath, ftp_file)
400 self.saveFigure(figpath, ftp_file)
401 ftp_filename = os.path.join(figpath,ftp_file)
401 ftp_filename = os.path.join(figpath,ftp_file)
402 try:
402 try:
403 self.sendByFTP(ftp_filename, server, folder, username, password)
403 self.sendByFTP(ftp_filename, server, folder, username, password)
404 except:
404 except:
405 self.counter_imagwr = 0
405 self.counter_imagwr = 0
406 print ValueError, 'Error FTP'
406 print ValueError, 'Error FTP'
407
407
408 self.counter_imagwr = 0
408 self.counter_imagwr = 0
409
409
410 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
410 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
411 self.__isConfig = False
411 self.__isConfig = False
412
412
413 class SpectraPlot(Figure):
413 class SpectraPlot(Figure):
414
414
415 __isConfig = None
415 __isConfig = None
416 __nsubplots = None
416 __nsubplots = None
417
417
418 WIDTHPROF = None
418 WIDTHPROF = None
419 HEIGHTPROF = None
419 HEIGHTPROF = None
420 PREFIX = 'spc'
420 PREFIX = 'spc'
421
421
422 def __init__(self):
422 def __init__(self):
423
423
424 self.__isConfig = False
424 self.__isConfig = False
425 self.__nsubplots = 1
425 self.__nsubplots = 1
426
426
427 self.WIDTH = 280
427 self.WIDTH = 280
428 self.HEIGHT = 250
428 self.HEIGHT = 250
429 self.WIDTHPROF = 120
429 self.WIDTHPROF = 120
430 self.HEIGHTPROF = 0
430 self.HEIGHTPROF = 0
431 self.counter_imagwr = 0
431 self.counter_imagwr = 0
432
432
433 self.PLOT_CODE = 1
433 self.PLOT_CODE = 1
434 self.FTP_WEI = None
434 self.FTP_WEI = None
435 self.EXP_CODE = None
435 self.EXP_CODE = None
436 self.SUB_EXP_CODE = None
436 self.SUB_EXP_CODE = None
437 self.PLOT_POS = None
437 self.PLOT_POS = None
438
438
439 def getSubplots(self):
439 def getSubplots(self):
440
440
441 ncol = int(numpy.sqrt(self.nplots)+0.9)
441 ncol = int(numpy.sqrt(self.nplots)+0.9)
442 nrow = int(self.nplots*1./ncol + 0.9)
442 nrow = int(self.nplots*1./ncol + 0.9)
443
443
444 return nrow, ncol
444 return nrow, ncol
445
445
446 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
446 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
447
447
448 self.__showprofile = showprofile
448 self.__showprofile = showprofile
449 self.nplots = nplots
449 self.nplots = nplots
450
450
451 ncolspan = 1
451 ncolspan = 1
452 colspan = 1
452 colspan = 1
453 if showprofile:
453 if showprofile:
454 ncolspan = 3
454 ncolspan = 3
455 colspan = 2
455 colspan = 2
456 self.__nsubplots = 2
456 self.__nsubplots = 2
457
457
458 self.createFigure(id = id,
458 self.createFigure(id = id,
459 wintitle = wintitle,
459 wintitle = wintitle,
460 widthplot = self.WIDTH + self.WIDTHPROF,
460 widthplot = self.WIDTH + self.WIDTHPROF,
461 heightplot = self.HEIGHT + self.HEIGHTPROF,
461 heightplot = self.HEIGHT + self.HEIGHTPROF,
462 show=show)
462 show=show)
463
463
464 nrow, ncol = self.getSubplots()
464 nrow, ncol = self.getSubplots()
465
465
466 counter = 0
466 counter = 0
467 for y in range(nrow):
467 for y in range(nrow):
468 for x in range(ncol):
468 for x in range(ncol):
469
469
470 if counter >= self.nplots:
470 if counter >= self.nplots:
471 break
471 break
472
472
473 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
473 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
474
474
475 if showprofile:
475 if showprofile:
476 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
476 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
477
477
478 counter += 1
478 counter += 1
479
479
480 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
480 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
481 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
481 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
482 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
482 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
483 server=None, folder=None, username=None, password=None,
483 server=None, folder=None, username=None, password=None,
484 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
484 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
485
485
486 """
486 """
487
487
488 Input:
488 Input:
489 dataOut :
489 dataOut :
490 id :
490 id :
491 wintitle :
491 wintitle :
492 channelList :
492 channelList :
493 showProfile :
493 showProfile :
494 xmin : None,
494 xmin : None,
495 xmax : None,
495 xmax : None,
496 ymin : None,
496 ymin : None,
497 ymax : None,
497 ymax : None,
498 zmin : None,
498 zmin : None,
499 zmax : None
499 zmax : None
500 """
500 """
501
501
502 if realtime:
502 if realtime:
503 if not(isRealtime(utcdatatime = dataOut.utctime)):
503 if not(isRealtime(utcdatatime = dataOut.utctime)):
504 print 'Skipping this plot function'
504 print 'Skipping this plot function'
505 return
505 return
506
506
507 if channelList == None:
507 if channelList == None:
508 channelIndexList = dataOut.channelIndexList
508 channelIndexList = dataOut.channelIndexList
509 else:
509 else:
510 channelIndexList = []
510 channelIndexList = []
511 for channel in channelList:
511 for channel in channelList:
512 if channel not in dataOut.channelList:
512 if channel not in dataOut.channelList:
513 raise ValueError, "Channel %d is not in dataOut.channelList"
513 raise ValueError, "Channel %d is not in dataOut.channelList"
514 channelIndexList.append(dataOut.channelList.index(channel))
514 channelIndexList.append(dataOut.channelList.index(channel))
515 factor = dataOut.normFactor
515 factor = dataOut.normFactor
516 x = dataOut.getVelRange(1)
516 x = dataOut.getVelRange(1)
517 y = dataOut.getHeiRange()
517 y = dataOut.getHeiRange()
518
518
519 z = dataOut.data_spc[channelIndexList,:,:]/factor
519 z = dataOut.data_spc[channelIndexList,:,:]/factor
520 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
520 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
521 avg = numpy.average(z, axis=1)
521 avg = numpy.average(z, axis=1)
522 noise = dataOut.getNoise()/factor
522 noise = dataOut.getNoise()/factor
523
523
524 zdB = 10*numpy.log10(z)
524 zdB = 10*numpy.log10(z)
525 avgdB = 10*numpy.log10(avg)
525 avgdB = 10*numpy.log10(avg)
526 noisedB = 10*numpy.log10(noise)
526 noisedB = 10*numpy.log10(noise)
527
527
528 #thisDatetime = dataOut.datatime
528 #thisDatetime = dataOut.datatime
529 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
529 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
530 title = wintitle + " Spectra"
530 title = wintitle + " Spectra"
531 xlabel = "Velocity (m/s)"
531 xlabel = "Velocity (m/s)"
532 ylabel = "Range (Km)"
532 ylabel = "Range (Km)"
533
533
534 if not self.__isConfig:
534 if not self.__isConfig:
535
535
536 nplots = len(channelIndexList)
536 nplots = len(channelIndexList)
537
537
538 self.setup(id=id,
538 self.setup(id=id,
539 nplots=nplots,
539 nplots=nplots,
540 wintitle=wintitle,
540 wintitle=wintitle,
541 showprofile=showprofile,
541 showprofile=showprofile,
542 show=show)
542 show=show)
543
543
544 if xmin == None: xmin = numpy.nanmin(x)
544 if xmin == None: xmin = numpy.nanmin(x)
545 if xmax == None: xmax = numpy.nanmax(x)
545 if xmax == None: xmax = numpy.nanmax(x)
546 if ymin == None: ymin = numpy.nanmin(y)
546 if ymin == None: ymin = numpy.nanmin(y)
547 if ymax == None: ymax = numpy.nanmax(y)
547 if ymax == None: ymax = numpy.nanmax(y)
548 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
548 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
549 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
549 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
550
550
551 self.FTP_WEI = ftp_wei
551 self.FTP_WEI = ftp_wei
552 self.EXP_CODE = exp_code
552 self.EXP_CODE = exp_code
553 self.SUB_EXP_CODE = sub_exp_code
553 self.SUB_EXP_CODE = sub_exp_code
554 self.PLOT_POS = plot_pos
554 self.PLOT_POS = plot_pos
555
555
556 self.__isConfig = True
556 self.__isConfig = True
557
557
558 self.setWinTitle(title)
558 self.setWinTitle(title)
559
559
560 for i in range(self.nplots):
560 for i in range(self.nplots):
561 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
561 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
562 title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i]+1, noisedB[i], str_datetime)
562 title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i]+1, noisedB[i], str_datetime)
563 axes = self.axesList[i*self.__nsubplots]
563 axes = self.axesList[i*self.__nsubplots]
564 axes.pcolor(x, y, zdB[i,:,:],
564 axes.pcolor(x, y, zdB[i,:,:],
565 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
565 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
566 xlabel=xlabel, ylabel=ylabel, title=title,
566 xlabel=xlabel, ylabel=ylabel, title=title,
567 ticksize=9, cblabel='')
567 ticksize=9, cblabel='')
568
568
569 if self.__showprofile:
569 if self.__showprofile:
570 axes = self.axesList[i*self.__nsubplots +1]
570 axes = self.axesList[i*self.__nsubplots +1]
571 axes.pline(avgdB[i], y,
571 axes.pline(avgdB[i], y,
572 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
572 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
573 xlabel='dB', ylabel='', title='',
573 xlabel='dB', ylabel='', title='',
574 ytick_visible=False,
574 ytick_visible=False,
575 grid='x')
575 grid='x')
576
576
577 noiseline = numpy.repeat(noisedB[i], len(y))
577 noiseline = numpy.repeat(noisedB[i], len(y))
578 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
578 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
579
579
580 self.draw()
580 self.draw()
581
581
582 if save:
582 if save:
583
583
584 self.counter_imagwr += 1
584 self.counter_imagwr += 1
585 if (self.counter_imagwr==wr_period):
585 if (self.counter_imagwr==wr_period):
586 if figfile == None:
586 if figfile == None:
587 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
587 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
588 figfile = self.getFilename(name = str_datetime)
588 figfile = self.getFilename(name = str_datetime)
589
589
590 self.saveFigure(figpath, figfile)
590 self.saveFigure(figpath, figfile)
591
591
592 if ftp:
592 if ftp:
593 #provisionalmente envia archivos en el formato de la web en tiempo real
593 #provisionalmente envia archivos en el formato de la web en tiempo real
594 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
594 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
595 path = '%s%03d' %(self.PREFIX, self.id)
595 path = '%s%03d' %(self.PREFIX, self.id)
596 ftp_file = os.path.join(path,'ftp','%s.png'%name)
596 ftp_file = os.path.join(path,'ftp','%s.png'%name)
597 self.saveFigure(figpath, ftp_file)
597 self.saveFigure(figpath, ftp_file)
598 ftp_filename = os.path.join(figpath,ftp_file)
598 ftp_filename = os.path.join(figpath,ftp_file)
599 try:
599 self.sendByFTP_Thread(ftp_filename, server, folder, username, password)
600 self.sendByFTP(ftp_filename, server, folder, username, password)
600 self.counter_imagwr = 0
601 except:
601
602 self.counter_imagwr = 0
603 print ValueError, 'Error FTP'
604
602
605 self.counter_imagwr = 0
603 self.counter_imagwr = 0
606
604
607
605
608 class Scope(Figure):
606 class Scope(Figure):
609
607
610 __isConfig = None
608 __isConfig = None
611
609
612 def __init__(self):
610 def __init__(self):
613
611
614 self.__isConfig = False
612 self.__isConfig = False
615 self.WIDTH = 600
613 self.WIDTH = 600
616 self.HEIGHT = 200
614 self.HEIGHT = 200
617
615
618 def getSubplots(self):
616 def getSubplots(self):
619
617
620 nrow = self.nplots
618 nrow = self.nplots
621 ncol = 3
619 ncol = 3
622 return nrow, ncol
620 return nrow, ncol
623
621
624 def setup(self, id, nplots, wintitle, show):
622 def setup(self, id, nplots, wintitle, show):
625
623
626 self.nplots = nplots
624 self.nplots = nplots
627
625
628 self.createFigure(id=id,
626 self.createFigure(id=id,
629 wintitle=wintitle,
627 wintitle=wintitle,
630 show=show)
628 show=show)
631
629
632 nrow,ncol = self.getSubplots()
630 nrow,ncol = self.getSubplots()
633 colspan = 3
631 colspan = 3
634 rowspan = 1
632 rowspan = 1
635
633
636 for i in range(nplots):
634 for i in range(nplots):
637 self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
635 self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
638
636
639
637
640
638
641 def run(self, dataOut, id, wintitle="", channelList=None,
639 def run(self, dataOut, id, wintitle="", channelList=None,
642 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
640 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
643 figpath='./', figfile=None, show=True):
641 figpath='./', figfile=None, show=True):
644
642
645 """
643 """
646
644
647 Input:
645 Input:
648 dataOut :
646 dataOut :
649 id :
647 id :
650 wintitle :
648 wintitle :
651 channelList :
649 channelList :
652 xmin : None,
650 xmin : None,
653 xmax : None,
651 xmax : None,
654 ymin : None,
652 ymin : None,
655 ymax : None,
653 ymax : None,
656 """
654 """
657
655
658 if channelList == None:
656 if channelList == None:
659 channelIndexList = dataOut.channelIndexList
657 channelIndexList = dataOut.channelIndexList
660 else:
658 else:
661 channelIndexList = []
659 channelIndexList = []
662 for channel in channelList:
660 for channel in channelList:
663 if channel not in dataOut.channelList:
661 if channel not in dataOut.channelList:
664 raise ValueError, "Channel %d is not in dataOut.channelList"
662 raise ValueError, "Channel %d is not in dataOut.channelList"
665 channelIndexList.append(dataOut.channelList.index(channel))
663 channelIndexList.append(dataOut.channelList.index(channel))
666
664
667 x = dataOut.heightList
665 x = dataOut.heightList
668 y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
666 y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
669 y = y.real
667 y = y.real
670
668
671 #thisDatetime = dataOut.datatime
669 #thisDatetime = dataOut.datatime
672 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
670 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
673 title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
671 title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
674 xlabel = "Range (Km)"
672 xlabel = "Range (Km)"
675 ylabel = "Intensity"
673 ylabel = "Intensity"
676
674
677 if not self.__isConfig:
675 if not self.__isConfig:
678 nplots = len(channelIndexList)
676 nplots = len(channelIndexList)
679
677
680 self.setup(id=id,
678 self.setup(id=id,
681 nplots=nplots,
679 nplots=nplots,
682 wintitle=wintitle,
680 wintitle=wintitle,
683 show=show)
681 show=show)
684
682
685 if xmin == None: xmin = numpy.nanmin(x)
683 if xmin == None: xmin = numpy.nanmin(x)
686 if xmax == None: xmax = numpy.nanmax(x)
684 if xmax == None: xmax = numpy.nanmax(x)
687 if ymin == None: ymin = numpy.nanmin(y)
685 if ymin == None: ymin = numpy.nanmin(y)
688 if ymax == None: ymax = numpy.nanmax(y)
686 if ymax == None: ymax = numpy.nanmax(y)
689
687
690 self.__isConfig = True
688 self.__isConfig = True
691
689
692 self.setWinTitle(title)
690 self.setWinTitle(title)
693
691
694 for i in range(len(self.axesList)):
692 for i in range(len(self.axesList)):
695 title = "Channel %d" %(i)
693 title = "Channel %d" %(i)
696 axes = self.axesList[i]
694 axes = self.axesList[i]
697 ychannel = y[i,:]
695 ychannel = y[i,:]
698 axes.pline(x, ychannel,
696 axes.pline(x, ychannel,
699 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
697 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
700 xlabel=xlabel, ylabel=ylabel, title=title)
698 xlabel=xlabel, ylabel=ylabel, title=title)
701
699
702 self.draw()
700 self.draw()
703
701
704 if save:
702 if save:
705 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
703 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
706 if figfile == None:
704 if figfile == None:
707 figfile = self.getFilename(name = date)
705 figfile = self.getFilename(name = date)
708
706
709 self.saveFigure(figpath, figfile)
707 self.saveFigure(figpath, figfile)
710
708
711 class PowerProfilePlot(Figure):
709 class PowerProfilePlot(Figure):
712 __isConfig = None
710 __isConfig = None
713 __nsubplots = None
711 __nsubplots = None
714
712
715 WIDTHPROF = None
713 WIDTHPROF = None
716 HEIGHTPROF = None
714 HEIGHTPROF = None
717 PREFIX = 'spcprofile'
715 PREFIX = 'spcprofile'
718
716
719 def __init__(self):
717 def __init__(self):
720 self.__isConfig = False
718 self.__isConfig = False
721 self.__nsubplots = 1
719 self.__nsubplots = 1
722
720
723 self.WIDTH = 300
721 self.WIDTH = 300
724 self.HEIGHT = 500
722 self.HEIGHT = 500
725
723
726 def getSubplots(self):
724 def getSubplots(self):
727 ncol = 1
725 ncol = 1
728 nrow = 1
726 nrow = 1
729
727
730 return nrow, ncol
728 return nrow, ncol
731
729
732 def setup(self, id, nplots, wintitle, show):
730 def setup(self, id, nplots, wintitle, show):
733
731
734 self.nplots = nplots
732 self.nplots = nplots
735
733
736 ncolspan = 1
734 ncolspan = 1
737 colspan = 1
735 colspan = 1
738
736
739 self.createFigure(id = id,
737 self.createFigure(id = id,
740 wintitle = wintitle,
738 wintitle = wintitle,
741 widthplot = self.WIDTH,
739 widthplot = self.WIDTH,
742 heightplot = self.HEIGHT,
740 heightplot = self.HEIGHT,
743 show=show)
741 show=show)
744
742
745 nrow, ncol = self.getSubplots()
743 nrow, ncol = self.getSubplots()
746
744
747 counter = 0
745 counter = 0
748 for y in range(nrow):
746 for y in range(nrow):
749 for x in range(ncol):
747 for x in range(ncol):
750 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
748 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
751
749
752 def run(self, dataOut, id, wintitle="", channelList=None,
750 def run(self, dataOut, id, wintitle="", channelList=None,
753 xmin=None, xmax=None, ymin=None, ymax=None,
751 xmin=None, xmax=None, ymin=None, ymax=None,
754 save=False, figpath='./', figfile=None, show=True):
752 save=False, figpath='./', figfile=None, show=True):
755
753
756 if channelList == None:
754 if channelList == None:
757 channelIndexList = dataOut.channelIndexList
755 channelIndexList = dataOut.channelIndexList
758 channelList = dataOut.channelList
756 channelList = dataOut.channelList
759 else:
757 else:
760 channelIndexList = []
758 channelIndexList = []
761 for channel in channelList:
759 for channel in channelList:
762 if channel not in dataOut.channelList:
760 if channel not in dataOut.channelList:
763 raise ValueError, "Channel %d is not in dataOut.channelList"
761 raise ValueError, "Channel %d is not in dataOut.channelList"
764 channelIndexList.append(dataOut.channelList.index(channel))
762 channelIndexList.append(dataOut.channelList.index(channel))
765
763
766 factor = dataOut.normFactor
764 factor = dataOut.normFactor
767 y = dataOut.getHeiRange()
765 y = dataOut.getHeiRange()
768 x = dataOut.data_spc[channelIndexList,:,:]/factor
766 x = dataOut.data_spc[channelIndexList,:,:]/factor
769 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
767 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
770 avg = numpy.average(x, axis=1)
768 avg = numpy.average(x, axis=1)
771
769
772 avgdB = 10*numpy.log10(avg)
770 avgdB = 10*numpy.log10(avg)
773
771
774 #thisDatetime = dataOut.datatime
772 #thisDatetime = dataOut.datatime
775 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
773 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
776 title = wintitle + " Power Profile %s" %(thisDatetime.strftime("%d-%b-%Y"))
774 title = wintitle + " Power Profile %s" %(thisDatetime.strftime("%d-%b-%Y"))
777 xlabel = "dB"
775 xlabel = "dB"
778 ylabel = "Range (Km)"
776 ylabel = "Range (Km)"
779
777
780 if not self.__isConfig:
778 if not self.__isConfig:
781
779
782 nplots = 1
780 nplots = 1
783
781
784 self.setup(id=id,
782 self.setup(id=id,
785 nplots=nplots,
783 nplots=nplots,
786 wintitle=wintitle,
784 wintitle=wintitle,
787 show=show)
785 show=show)
788
786
789 if ymin == None: ymin = numpy.nanmin(y)
787 if ymin == None: ymin = numpy.nanmin(y)
790 if ymax == None: ymax = numpy.nanmax(y)
788 if ymax == None: ymax = numpy.nanmax(y)
791 if xmin == None: xmin = numpy.nanmin(avgdB)*0.9
789 if xmin == None: xmin = numpy.nanmin(avgdB)*0.9
792 if xmax == None: xmax = numpy.nanmax(avgdB)*0.9
790 if xmax == None: xmax = numpy.nanmax(avgdB)*0.9
793
791
794 self.__isConfig = True
792 self.__isConfig = True
795
793
796 self.setWinTitle(title)
794 self.setWinTitle(title)
797
795
798
796
799 title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
797 title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
800 axes = self.axesList[0]
798 axes = self.axesList[0]
801
799
802 legendlabels = ["channel %d"%x for x in channelList]
800 legendlabels = ["channel %d"%x for x in channelList]
803 axes.pmultiline(avgdB, y,
801 axes.pmultiline(avgdB, y,
804 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
802 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
805 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
803 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
806 ytick_visible=True, nxticks=5,
804 ytick_visible=True, nxticks=5,
807 grid='x')
805 grid='x')
808
806
809 self.draw()
807 self.draw()
810
808
811 if save:
809 if save:
812 date = thisDatetime.strftime("%Y%m%d")
810 date = thisDatetime.strftime("%Y%m%d")
813 if figfile == None:
811 if figfile == None:
814 figfile = self.getFilename(name = date)
812 figfile = self.getFilename(name = date)
815
813
816 self.saveFigure(figpath, figfile)
814 self.saveFigure(figpath, figfile)
817
815
818 class CoherenceMap(Figure):
816 class CoherenceMap(Figure):
819 __isConfig = None
817 __isConfig = None
820 __nsubplots = None
818 __nsubplots = None
821
819
822 WIDTHPROF = None
820 WIDTHPROF = None
823 HEIGHTPROF = None
821 HEIGHTPROF = None
824 PREFIX = 'cmap'
822 PREFIX = 'cmap'
825
823
826 def __init__(self):
824 def __init__(self):
827 self.timerange = 2*60*60
825 self.timerange = 2*60*60
828 self.__isConfig = False
826 self.__isConfig = False
829 self.__nsubplots = 1
827 self.__nsubplots = 1
830
828
831 self.WIDTH = 800
829 self.WIDTH = 800
832 self.HEIGHT = 150
830 self.HEIGHT = 150
833 self.WIDTHPROF = 120
831 self.WIDTHPROF = 120
834 self.HEIGHTPROF = 0
832 self.HEIGHTPROF = 0
835 self.counter_imagwr = 0
833 self.counter_imagwr = 0
836
834
837 self.PLOT_CODE = 3
835 self.PLOT_CODE = 3
838 self.FTP_WEI = None
836 self.FTP_WEI = None
839 self.EXP_CODE = None
837 self.EXP_CODE = None
840 self.SUB_EXP_CODE = None
838 self.SUB_EXP_CODE = None
841 self.PLOT_POS = None
839 self.PLOT_POS = None
842 self.counter_imagwr = 0
840 self.counter_imagwr = 0
843
841
844 def getSubplots(self):
842 def getSubplots(self):
845 ncol = 1
843 ncol = 1
846 nrow = self.nplots*2
844 nrow = self.nplots*2
847
845
848 return nrow, ncol
846 return nrow, ncol
849
847
850 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
848 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
851 self.__showprofile = showprofile
849 self.__showprofile = showprofile
852 self.nplots = nplots
850 self.nplots = nplots
853
851
854 ncolspan = 1
852 ncolspan = 1
855 colspan = 1
853 colspan = 1
856 if showprofile:
854 if showprofile:
857 ncolspan = 7
855 ncolspan = 7
858 colspan = 6
856 colspan = 6
859 self.__nsubplots = 2
857 self.__nsubplots = 2
860
858
861 self.createFigure(id = id,
859 self.createFigure(id = id,
862 wintitle = wintitle,
860 wintitle = wintitle,
863 widthplot = self.WIDTH + self.WIDTHPROF,
861 widthplot = self.WIDTH + self.WIDTHPROF,
864 heightplot = self.HEIGHT + self.HEIGHTPROF,
862 heightplot = self.HEIGHT + self.HEIGHTPROF,
865 show=True)
863 show=True)
866
864
867 nrow, ncol = self.getSubplots()
865 nrow, ncol = self.getSubplots()
868
866
869 for y in range(nrow):
867 for y in range(nrow):
870 for x in range(ncol):
868 for x in range(ncol):
871
869
872 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
870 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
873
871
874 if showprofile:
872 if showprofile:
875 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
873 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
876
874
877 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
875 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
878 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
876 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
879 timerange=None,
877 timerange=None,
880 save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
878 save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
881 coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
879 coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
882 server=None, folder=None, username=None, password=None,
880 server=None, folder=None, username=None, password=None,
883 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
881 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
884
882
885 if pairsList == None:
883 if pairsList == None:
886 pairsIndexList = dataOut.pairsIndexList
884 pairsIndexList = dataOut.pairsIndexList
887 else:
885 else:
888 pairsIndexList = []
886 pairsIndexList = []
889 for pair in pairsList:
887 for pair in pairsList:
890 if pair not in dataOut.pairsList:
888 if pair not in dataOut.pairsList:
891 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
889 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
892 pairsIndexList.append(dataOut.pairsList.index(pair))
890 pairsIndexList.append(dataOut.pairsList.index(pair))
893
891
894 if timerange != None:
892 if timerange != None:
895 self.timerange = timerange
893 self.timerange = timerange
896
894
897 if pairsIndexList == []:
895 if pairsIndexList == []:
898 return
896 return
899
897
900 if len(pairsIndexList) > 4:
898 if len(pairsIndexList) > 4:
901 pairsIndexList = pairsIndexList[0:4]
899 pairsIndexList = pairsIndexList[0:4]
902
900
903 tmin = None
901 tmin = None
904 tmax = None
902 tmax = None
905 x = dataOut.getTimeRange()
903 x = dataOut.getTimeRange()
906 y = dataOut.getHeiRange()
904 y = dataOut.getHeiRange()
907
905
908 #thisDatetime = dataOut.datatime
906 #thisDatetime = dataOut.datatime
909 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
907 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
910 title = wintitle + " CoherenceMap" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
908 title = wintitle + " CoherenceMap" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
911 xlabel = ""
909 xlabel = ""
912 ylabel = "Range (Km)"
910 ylabel = "Range (Km)"
913
911
914 if not self.__isConfig:
912 if not self.__isConfig:
915 nplots = len(pairsIndexList)
913 nplots = len(pairsIndexList)
916 self.setup(id=id,
914 self.setup(id=id,
917 nplots=nplots,
915 nplots=nplots,
918 wintitle=wintitle,
916 wintitle=wintitle,
919 showprofile=showprofile,
917 showprofile=showprofile,
920 show=show)
918 show=show)
921
919
922 tmin, tmax = self.getTimeLim(x, xmin, xmax)
920 tmin, tmax = self.getTimeLim(x, xmin, xmax)
923 if ymin == None: ymin = numpy.nanmin(y)
921 if ymin == None: ymin = numpy.nanmin(y)
924 if ymax == None: ymax = numpy.nanmax(y)
922 if ymax == None: ymax = numpy.nanmax(y)
925 if zmin == None: zmin = 0.
923 if zmin == None: zmin = 0.
926 if zmax == None: zmax = 1.
924 if zmax == None: zmax = 1.
927
925
928 self.FTP_WEI = ftp_wei
926 self.FTP_WEI = ftp_wei
929 self.EXP_CODE = exp_code
927 self.EXP_CODE = exp_code
930 self.SUB_EXP_CODE = sub_exp_code
928 self.SUB_EXP_CODE = sub_exp_code
931 self.PLOT_POS = plot_pos
929 self.PLOT_POS = plot_pos
932
930
933 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
931 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
934
932
935 self.__isConfig = True
933 self.__isConfig = True
936
934
937 self.setWinTitle(title)
935 self.setWinTitle(title)
938
936
939 for i in range(self.nplots):
937 for i in range(self.nplots):
940
938
941 pair = dataOut.pairsList[pairsIndexList[i]]
939 pair = dataOut.pairsList[pairsIndexList[i]]
942 # coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
940 # coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
943 # avgcoherenceComplex = numpy.average(coherenceComplex, axis=0)
941 # avgcoherenceComplex = numpy.average(coherenceComplex, axis=0)
944 # coherence = numpy.abs(avgcoherenceComplex)
942 # coherence = numpy.abs(avgcoherenceComplex)
945
943
946 ## coherence = numpy.abs(coherenceComplex)
944 ## coherence = numpy.abs(coherenceComplex)
947 ## avg = numpy.average(coherence, axis=0)
945 ## avg = numpy.average(coherence, axis=0)
948
946
949 ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
947 ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
950 powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
948 powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
951 powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
949 powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
952
950
953
951
954 avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
952 avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
955 coherence = numpy.abs(avgcoherenceComplex)
953 coherence = numpy.abs(avgcoherenceComplex)
956
954
957 z = coherence.reshape((1,-1))
955 z = coherence.reshape((1,-1))
958
956
959 counter = 0
957 counter = 0
960
958
961 title = "Coherence %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
959 title = "Coherence %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
962 axes = self.axesList[i*self.__nsubplots*2]
960 axes = self.axesList[i*self.__nsubplots*2]
963 axes.pcolorbuffer(x, y, z,
961 axes.pcolorbuffer(x, y, z,
964 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
962 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
965 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
963 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
966 ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
964 ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
967
965
968 if self.__showprofile:
966 if self.__showprofile:
969 counter += 1
967 counter += 1
970 axes = self.axesList[i*self.__nsubplots*2 + counter]
968 axes = self.axesList[i*self.__nsubplots*2 + counter]
971 axes.pline(coherence, y,
969 axes.pline(coherence, y,
972 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
970 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
973 xlabel='', ylabel='', title='', ticksize=7,
971 xlabel='', ylabel='', title='', ticksize=7,
974 ytick_visible=False, nxticks=5,
972 ytick_visible=False, nxticks=5,
975 grid='x')
973 grid='x')
976
974
977 counter += 1
975 counter += 1
978 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
976 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
979 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
977 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
980 # avg = numpy.average(phase, axis=0)
978 # avg = numpy.average(phase, axis=0)
981 z = phase.reshape((1,-1))
979 z = phase.reshape((1,-1))
982
980
983 title = "Phase %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
981 title = "Phase %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
984 axes = self.axesList[i*self.__nsubplots*2 + counter]
982 axes = self.axesList[i*self.__nsubplots*2 + counter]
985 axes.pcolorbuffer(x, y, z,
983 axes.pcolorbuffer(x, y, z,
986 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
984 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
987 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
985 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
988 ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
986 ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
989
987
990 if self.__showprofile:
988 if self.__showprofile:
991 counter += 1
989 counter += 1
992 axes = self.axesList[i*self.__nsubplots*2 + counter]
990 axes = self.axesList[i*self.__nsubplots*2 + counter]
993 axes.pline(phase, y,
991 axes.pline(phase, y,
994 xmin=-180, xmax=180, ymin=ymin, ymax=ymax,
992 xmin=-180, xmax=180, ymin=ymin, ymax=ymax,
995 xlabel='', ylabel='', title='', ticksize=7,
993 xlabel='', ylabel='', title='', ticksize=7,
996 ytick_visible=False, nxticks=4,
994 ytick_visible=False, nxticks=4,
997 grid='x')
995 grid='x')
998
996
999 self.draw()
997 self.draw()
1000
998
1001 if save:
999 if save:
1002
1000
1003 self.counter_imagwr += 1
1001 self.counter_imagwr += 1
1004 if (self.counter_imagwr==wr_period):
1002 if (self.counter_imagwr==wr_period):
1005 if figfile == None:
1003 if figfile == None:
1006 figfile = self.getFilename(name = self.name)
1004 figfile = self.getFilename(name = self.name)
1007 self.saveFigure(figpath, figfile)
1005 self.saveFigure(figpath, figfile)
1008
1006
1009 if ftp:
1007 if ftp:
1010 #provisionalmente envia archivos en el formato de la web en tiempo real
1008 #provisionalmente envia archivos en el formato de la web en tiempo real
1011 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
1009 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
1012 path = '%s%03d' %(self.PREFIX, self.id)
1010 path = '%s%03d' %(self.PREFIX, self.id)
1013 ftp_file = os.path.join(path,'ftp','%s.png'%name)
1011 ftp_file = os.path.join(path,'ftp','%s.png'%name)
1014 self.saveFigure(figpath, ftp_file)
1012 self.saveFigure(figpath, ftp_file)
1015 ftp_filename = os.path.join(figpath,ftp_file)
1013 ftp_filename = os.path.join(figpath,ftp_file)
1016 try:
1014 try:
1017 self.sendByFTP(ftp_filename, server, folder, username, password)
1015 self.sendByFTP(ftp_filename, server, folder, username, password)
1018 except:
1016 except:
1019 self.counter_imagwr = 0
1017 self.counter_imagwr = 0
1020 print ValueError, 'Error FTP'
1018 print ValueError, 'Error FTP'
1021
1019
1022 self.counter_imagwr = 0
1020 self.counter_imagwr = 0
1023
1021
1024
1022
1025 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
1023 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
1026 self.__isConfig = False
1024 self.__isConfig = False
1027
1025
1028 class Noise(Figure):
1026 class Noise(Figure):
1029
1027
1030 __isConfig = None
1028 __isConfig = None
1031 __nsubplots = None
1029 __nsubplots = None
1032
1030
1033 PREFIX = 'noise'
1031 PREFIX = 'noise'
1034
1032
1035 def __init__(self):
1033 def __init__(self):
1036
1034
1037 self.timerange = 24*60*60
1035 self.timerange = 24*60*60
1038 self.__isConfig = False
1036 self.__isConfig = False
1039 self.__nsubplots = 1
1037 self.__nsubplots = 1
1040 self.counter_imagwr = 0
1038 self.counter_imagwr = 0
1041 self.WIDTH = 600
1039 self.WIDTH = 600
1042 self.HEIGHT = 300
1040 self.HEIGHT = 300
1043 self.WIDTHPROF = 120
1041 self.WIDTHPROF = 120
1044 self.HEIGHTPROF = 0
1042 self.HEIGHTPROF = 0
1045 self.xdata = None
1043 self.xdata = None
1046 self.ydata = None
1044 self.ydata = None
1047
1045
1048 self.PLOT_CODE = 77
1046 self.PLOT_CODE = 77
1049 self.FTP_WEI = None
1047 self.FTP_WEI = None
1050 self.EXP_CODE = None
1048 self.EXP_CODE = None
1051 self.SUB_EXP_CODE = None
1049 self.SUB_EXP_CODE = None
1052 self.PLOT_POS = None
1050 self.PLOT_POS = None
1053
1051
1054 def getSubplots(self):
1052 def getSubplots(self):
1055
1053
1056 ncol = 1
1054 ncol = 1
1057 nrow = 1
1055 nrow = 1
1058
1056
1059 return nrow, ncol
1057 return nrow, ncol
1060
1058
1061 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1059 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1062
1060
1063 self.__showprofile = showprofile
1061 self.__showprofile = showprofile
1064 self.nplots = nplots
1062 self.nplots = nplots
1065
1063
1066 ncolspan = 7
1064 ncolspan = 7
1067 colspan = 6
1065 colspan = 6
1068 self.__nsubplots = 2
1066 self.__nsubplots = 2
1069
1067
1070 self.createFigure(id = id,
1068 self.createFigure(id = id,
1071 wintitle = wintitle,
1069 wintitle = wintitle,
1072 widthplot = self.WIDTH+self.WIDTHPROF,
1070 widthplot = self.WIDTH+self.WIDTHPROF,
1073 heightplot = self.HEIGHT+self.HEIGHTPROF,
1071 heightplot = self.HEIGHT+self.HEIGHTPROF,
1074 show=show)
1072 show=show)
1075
1073
1076 nrow, ncol = self.getSubplots()
1074 nrow, ncol = self.getSubplots()
1077
1075
1078 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1076 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1079
1077
1080
1078
1081 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
1079 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
1082 xmin=None, xmax=None, ymin=None, ymax=None,
1080 xmin=None, xmax=None, ymin=None, ymax=None,
1083 timerange=None,
1081 timerange=None,
1084 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
1082 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
1085 server=None, folder=None, username=None, password=None,
1083 server=None, folder=None, username=None, password=None,
1086 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1084 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1087
1085
1088 if channelList == None:
1086 if channelList == None:
1089 channelIndexList = dataOut.channelIndexList
1087 channelIndexList = dataOut.channelIndexList
1090 channelList = dataOut.channelList
1088 channelList = dataOut.channelList
1091 else:
1089 else:
1092 channelIndexList = []
1090 channelIndexList = []
1093 for channel in channelList:
1091 for channel in channelList:
1094 if channel not in dataOut.channelList:
1092 if channel not in dataOut.channelList:
1095 raise ValueError, "Channel %d is not in dataOut.channelList"
1093 raise ValueError, "Channel %d is not in dataOut.channelList"
1096 channelIndexList.append(dataOut.channelList.index(channel))
1094 channelIndexList.append(dataOut.channelList.index(channel))
1097
1095
1098 if timerange != None:
1096 if timerange != None:
1099 self.timerange = timerange
1097 self.timerange = timerange
1100
1098
1101 tmin = None
1099 tmin = None
1102 tmax = None
1100 tmax = None
1103 x = dataOut.getTimeRange()
1101 x = dataOut.getTimeRange()
1104 y = dataOut.getHeiRange()
1102 y = dataOut.getHeiRange()
1105 factor = dataOut.normFactor
1103 factor = dataOut.normFactor
1106 noise = dataOut.getNoise()/factor
1104 noise = dataOut.getNoise()/factor
1107 noisedB = 10*numpy.log10(noise)
1105 noisedB = 10*numpy.log10(noise)
1108
1106
1109 #thisDatetime = dataOut.datatime
1107 #thisDatetime = dataOut.datatime
1110 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
1108 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
1111 title = wintitle + " Noise" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
1109 title = wintitle + " Noise" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
1112 xlabel = ""
1110 xlabel = ""
1113 ylabel = "Intensity (dB)"
1111 ylabel = "Intensity (dB)"
1114
1112
1115 if not self.__isConfig:
1113 if not self.__isConfig:
1116
1114
1117 nplots = 1
1115 nplots = 1
1118
1116
1119 self.setup(id=id,
1117 self.setup(id=id,
1120 nplots=nplots,
1118 nplots=nplots,
1121 wintitle=wintitle,
1119 wintitle=wintitle,
1122 showprofile=showprofile,
1120 showprofile=showprofile,
1123 show=show)
1121 show=show)
1124
1122
1125 tmin, tmax = self.getTimeLim(x, xmin, xmax)
1123 tmin, tmax = self.getTimeLim(x, xmin, xmax)
1126 if ymin == None: ymin = numpy.nanmin(noisedB) - 10.0
1124 if ymin == None: ymin = numpy.nanmin(noisedB) - 10.0
1127 if ymax == None: ymax = numpy.nanmax(noisedB) + 10.0
1125 if ymax == None: ymax = numpy.nanmax(noisedB) + 10.0
1128
1126
1129 self.FTP_WEI = ftp_wei
1127 self.FTP_WEI = ftp_wei
1130 self.EXP_CODE = exp_code
1128 self.EXP_CODE = exp_code
1131 self.SUB_EXP_CODE = sub_exp_code
1129 self.SUB_EXP_CODE = sub_exp_code
1132 self.PLOT_POS = plot_pos
1130 self.PLOT_POS = plot_pos
1133
1131
1134 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1132 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1135
1133
1136
1134
1137 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1135 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1138 self.__isConfig = True
1136 self.__isConfig = True
1139
1137
1140 self.xdata = numpy.array([])
1138 self.xdata = numpy.array([])
1141 self.ydata = numpy.array([])
1139 self.ydata = numpy.array([])
1142
1140
1143 self.setWinTitle(title)
1141 self.setWinTitle(title)
1144
1142
1145
1143
1146 title = "Noise %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1144 title = "Noise %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1147
1145
1148 legendlabels = ["channel %d"%(idchannel+1) for idchannel in channelList]
1146 legendlabels = ["channel %d"%(idchannel+1) for idchannel in channelList]
1149 axes = self.axesList[0]
1147 axes = self.axesList[0]
1150
1148
1151 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1149 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1152
1150
1153 if len(self.ydata)==0:
1151 if len(self.ydata)==0:
1154 self.ydata = noisedB[channelIndexList].reshape(-1,1)
1152 self.ydata = noisedB[channelIndexList].reshape(-1,1)
1155 else:
1153 else:
1156 self.ydata = numpy.hstack((self.ydata, noisedB[channelIndexList].reshape(-1,1)))
1154 self.ydata = numpy.hstack((self.ydata, noisedB[channelIndexList].reshape(-1,1)))
1157
1155
1158
1156
1159 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1157 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1160 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
1158 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
1161 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1159 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1162 XAxisAsTime=True, grid='both'
1160 XAxisAsTime=True, grid='both'
1163 )
1161 )
1164
1162
1165 self.draw()
1163 self.draw()
1166
1164
1167 # if save:
1165 # if save:
1168 #
1166 #
1169 # if figfile == None:
1167 # if figfile == None:
1170 # figfile = self.getFilename(name = self.name)
1168 # figfile = self.getFilename(name = self.name)
1171 #
1169 #
1172 # self.saveFigure(figpath, figfile)
1170 # self.saveFigure(figpath, figfile)
1173
1171
1174 if save:
1172 if save:
1175
1173
1176 self.counter_imagwr += 1
1174 self.counter_imagwr += 1
1177 if (self.counter_imagwr==wr_period):
1175 if (self.counter_imagwr==wr_period):
1178 if figfile == None:
1176 if figfile == None:
1179 figfile = self.getFilename(name = self.name)
1177 figfile = self.getFilename(name = self.name)
1180 self.saveFigure(figpath, figfile)
1178 self.saveFigure(figpath, figfile)
1181
1179
1182 if ftp:
1180 if ftp:
1183 #provisionalmente envia archivos en el formato de la web en tiempo real
1181 #provisionalmente envia archivos en el formato de la web en tiempo real
1184 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
1182 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
1185 path = '%s%03d' %(self.PREFIX, self.id)
1183 path = '%s%03d' %(self.PREFIX, self.id)
1186 ftp_file = os.path.join(path,'ftp','%s.png'%name)
1184 ftp_file = os.path.join(path,'ftp','%s.png'%name)
1187 self.saveFigure(figpath, ftp_file)
1185 self.saveFigure(figpath, ftp_file)
1188 ftp_filename = os.path.join(figpath,ftp_file)
1186 ftp_filename = os.path.join(figpath,ftp_file)
1189 try:
1187 try:
1190 self.sendByFTP(ftp_filename, server, folder, username, password)
1188 self.sendByFTP(ftp_filename, server, folder, username, password)
1191 except:
1189 except:
1192 self.counter_imagwr = 0
1190 self.counter_imagwr = 0
1193 print ValueError, 'Error FTP'
1191 print ValueError, 'Error FTP'
1194
1192
1195 self.counter_imagwr = 0
1193 self.counter_imagwr = 0
1196
1194
1197 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
1195 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
1198 self.__isConfig = False
1196 self.__isConfig = False
1199 del self.xdata
1197 del self.xdata
1200 del self.ydata
1198 del self.ydata
1201
1199
1202
1200
1203 class SpectraHeisScope(Figure):
1201 class SpectraHeisScope(Figure):
1204
1202
1205
1203
1206 __isConfig = None
1204 __isConfig = None
1207 __nsubplots = None
1205 __nsubplots = None
1208
1206
1209 WIDTHPROF = None
1207 WIDTHPROF = None
1210 HEIGHTPROF = None
1208 HEIGHTPROF = None
1211 PREFIX = 'spc'
1209 PREFIX = 'spc'
1212
1210
1213 def __init__(self):
1211 def __init__(self):
1214
1212
1215 self.__isConfig = False
1213 self.__isConfig = False
1216 self.__nsubplots = 1
1214 self.__nsubplots = 1
1217
1215
1218 self.WIDTH = 230
1216 self.WIDTH = 230
1219 self.HEIGHT = 250
1217 self.HEIGHT = 250
1220 self.WIDTHPROF = 120
1218 self.WIDTHPROF = 120
1221 self.HEIGHTPROF = 0
1219 self.HEIGHTPROF = 0
1222 self.counter_imagwr = 0
1220 self.counter_imagwr = 0
1223
1221
1224 def getSubplots(self):
1222 def getSubplots(self):
1225
1223
1226 ncol = int(numpy.sqrt(self.nplots)+0.9)
1224 ncol = int(numpy.sqrt(self.nplots)+0.9)
1227 nrow = int(self.nplots*1./ncol + 0.9)
1225 nrow = int(self.nplots*1./ncol + 0.9)
1228
1226
1229 return nrow, ncol
1227 return nrow, ncol
1230
1228
1231 def setup(self, id, nplots, wintitle, show):
1229 def setup(self, id, nplots, wintitle, show):
1232
1230
1233 showprofile = False
1231 showprofile = False
1234 self.__showprofile = showprofile
1232 self.__showprofile = showprofile
1235 self.nplots = nplots
1233 self.nplots = nplots
1236
1234
1237 ncolspan = 1
1235 ncolspan = 1
1238 colspan = 1
1236 colspan = 1
1239 if showprofile:
1237 if showprofile:
1240 ncolspan = 3
1238 ncolspan = 3
1241 colspan = 2
1239 colspan = 2
1242 self.__nsubplots = 2
1240 self.__nsubplots = 2
1243
1241
1244 self.createFigure(id = id,
1242 self.createFigure(id = id,
1245 wintitle = wintitle,
1243 wintitle = wintitle,
1246 widthplot = self.WIDTH + self.WIDTHPROF,
1244 widthplot = self.WIDTH + self.WIDTHPROF,
1247 heightplot = self.HEIGHT + self.HEIGHTPROF,
1245 heightplot = self.HEIGHT + self.HEIGHTPROF,
1248 show = show)
1246 show = show)
1249
1247
1250 nrow, ncol = self.getSubplots()
1248 nrow, ncol = self.getSubplots()
1251
1249
1252 counter = 0
1250 counter = 0
1253 for y in range(nrow):
1251 for y in range(nrow):
1254 for x in range(ncol):
1252 for x in range(ncol):
1255
1253
1256 if counter >= self.nplots:
1254 if counter >= self.nplots:
1257 break
1255 break
1258
1256
1259 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
1257 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
1260
1258
1261 if showprofile:
1259 if showprofile:
1262 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
1260 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
1263
1261
1264 counter += 1
1262 counter += 1
1265
1263
1266 # __isConfig = None
1264 # __isConfig = None
1267 # def __init__(self):
1265 # def __init__(self):
1268 #
1266 #
1269 # self.__isConfig = False
1267 # self.__isConfig = False
1270 # self.WIDTH = 600
1268 # self.WIDTH = 600
1271 # self.HEIGHT = 200
1269 # self.HEIGHT = 200
1272 #
1270 #
1273 # def getSubplots(self):
1271 # def getSubplots(self):
1274 #
1272 #
1275 # nrow = self.nplots
1273 # nrow = self.nplots
1276 # ncol = 3
1274 # ncol = 3
1277 # return nrow, ncol
1275 # return nrow, ncol
1278 #
1276 #
1279 # def setup(self, id, nplots, wintitle):
1277 # def setup(self, id, nplots, wintitle):
1280 #
1278 #
1281 # self.nplots = nplots
1279 # self.nplots = nplots
1282 #
1280 #
1283 # self.createFigure(id, wintitle)
1281 # self.createFigure(id, wintitle)
1284 #
1282 #
1285 # nrow,ncol = self.getSubplots()
1283 # nrow,ncol = self.getSubplots()
1286 # colspan = 3
1284 # colspan = 3
1287 # rowspan = 1
1285 # rowspan = 1
1288 #
1286 #
1289 # for i in range(nplots):
1287 # for i in range(nplots):
1290 # self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
1288 # self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
1291
1289
1292 def run(self, dataOut, id, wintitle="", channelList=None,
1290 def run(self, dataOut, id, wintitle="", channelList=None,
1293 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
1291 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
1294 figpath='./', figfile=None, ftp=False, wr_period=1, show=True):
1292 figpath='./', figfile=None, ftp=False, wr_period=1, show=True):
1295
1293
1296 """
1294 """
1297
1295
1298 Input:
1296 Input:
1299 dataOut :
1297 dataOut :
1300 id :
1298 id :
1301 wintitle :
1299 wintitle :
1302 channelList :
1300 channelList :
1303 xmin : None,
1301 xmin : None,
1304 xmax : None,
1302 xmax : None,
1305 ymin : None,
1303 ymin : None,
1306 ymax : None,
1304 ymax : None,
1307 """
1305 """
1308
1306
1309 if dataOut.realtime:
1307 if dataOut.realtime:
1310 if not(isRealtime(utcdatatime = dataOut.utctime)):
1308 if not(isRealtime(utcdatatime = dataOut.utctime)):
1311 print 'Skipping this plot function'
1309 print 'Skipping this plot function'
1312 return
1310 return
1313
1311
1314 if channelList == None:
1312 if channelList == None:
1315 channelIndexList = dataOut.channelIndexList
1313 channelIndexList = dataOut.channelIndexList
1316 else:
1314 else:
1317 channelIndexList = []
1315 channelIndexList = []
1318 for channel in channelList:
1316 for channel in channelList:
1319 if channel not in dataOut.channelList:
1317 if channel not in dataOut.channelList:
1320 raise ValueError, "Channel %d is not in dataOut.channelList"
1318 raise ValueError, "Channel %d is not in dataOut.channelList"
1321 channelIndexList.append(dataOut.channelList.index(channel))
1319 channelIndexList.append(dataOut.channelList.index(channel))
1322
1320
1323 # x = dataOut.heightList
1321 # x = dataOut.heightList
1324 c = 3E8
1322 c = 3E8
1325 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1323 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
1326 #deberia cambiar para el caso de 1Mhz y 100KHz
1324 #deberia cambiar para el caso de 1Mhz y 100KHz
1327 x = numpy.arange(-1*dataOut.nHeights/2.,dataOut.nHeights/2.)*(c/(2*deltaHeight*dataOut.nHeights*1000))
1325 x = numpy.arange(-1*dataOut.nHeights/2.,dataOut.nHeights/2.)*(c/(2*deltaHeight*dataOut.nHeights*1000))
1328 x= x/(10000.0)
1326 x= x/(10000.0)
1329 # y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
1327 # y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
1330 # y = y.real
1328 # y = y.real
1331 datadB = 10.*numpy.log10(dataOut.data_spc)
1329 datadB = 10.*numpy.log10(dataOut.data_spc)
1332 y = datadB
1330 y = datadB
1333
1331
1334 #thisDatetime = dataOut.datatime
1332 #thisDatetime = dataOut.datatime
1335 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
1333 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
1336 title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
1334 title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
1337 xlabel = "Frequency x 10000"
1335 xlabel = "Frequency x 10000"
1338 ylabel = "Intensity (dB)"
1336 ylabel = "Intensity (dB)"
1339
1337
1340 if not self.__isConfig:
1338 if not self.__isConfig:
1341 nplots = len(channelIndexList)
1339 nplots = len(channelIndexList)
1342
1340
1343 self.setup(id=id,
1341 self.setup(id=id,
1344 nplots=nplots,
1342 nplots=nplots,
1345 wintitle=wintitle,
1343 wintitle=wintitle,
1346 show=show)
1344 show=show)
1347
1345
1348 if xmin == None: xmin = numpy.nanmin(x)
1346 if xmin == None: xmin = numpy.nanmin(x)
1349 if xmax == None: xmax = numpy.nanmax(x)
1347 if xmax == None: xmax = numpy.nanmax(x)
1350 if ymin == None: ymin = numpy.nanmin(y)
1348 if ymin == None: ymin = numpy.nanmin(y)
1351 if ymax == None: ymax = numpy.nanmax(y)
1349 if ymax == None: ymax = numpy.nanmax(y)
1352
1350
1353 self.__isConfig = True
1351 self.__isConfig = True
1354
1352
1355 self.setWinTitle(title)
1353 self.setWinTitle(title)
1356
1354
1357 for i in range(len(self.axesList)):
1355 for i in range(len(self.axesList)):
1358 ychannel = y[i,:]
1356 ychannel = y[i,:]
1359 title = "Channel %d - peak:%.2f" %(i,numpy.max(ychannel))
1357 title = "Channel %d - peak:%.2f" %(i,numpy.max(ychannel))
1360 axes = self.axesList[i]
1358 axes = self.axesList[i]
1361 axes.pline(x, ychannel,
1359 axes.pline(x, ychannel,
1362 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
1360 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
1363 xlabel=xlabel, ylabel=ylabel, title=title, grid='both')
1361 xlabel=xlabel, ylabel=ylabel, title=title, grid='both')
1364
1362
1365
1363
1366 self.draw()
1364 self.draw()
1367
1365
1368 if save:
1366 if save:
1369 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
1367 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
1370 if figfile == None:
1368 if figfile == None:
1371 figfile = self.getFilename(name = date)
1369 figfile = self.getFilename(name = date)
1372
1370
1373 self.saveFigure(figpath, figfile)
1371 self.saveFigure(figpath, figfile)
1374
1372
1375 self.counter_imagwr += 1
1373 self.counter_imagwr += 1
1376 if (ftp and (self.counter_imagwr==wr_period)):
1374 if (ftp and (self.counter_imagwr==wr_period)):
1377 figfilename = os.path.join(figpath,figfile)
1375 figfilename = os.path.join(figpath,figfile)
1378 self.sendByFTP(figfilename)
1376 self.sendByFTP(figfilename)
1379 self.counter_imagwr = 0
1377 self.counter_imagwr = 0
1380
1378
1381
1379
1382 class RTIfromSpectraHeis(Figure):
1380 class RTIfromSpectraHeis(Figure):
1383
1381
1384 __isConfig = None
1382 __isConfig = None
1385 __nsubplots = None
1383 __nsubplots = None
1386
1384
1387 PREFIX = 'rtinoise'
1385 PREFIX = 'rtinoise'
1388
1386
1389 def __init__(self):
1387 def __init__(self):
1390
1388
1391 self.timerange = 24*60*60
1389 self.timerange = 24*60*60
1392 self.__isConfig = False
1390 self.__isConfig = False
1393 self.__nsubplots = 1
1391 self.__nsubplots = 1
1394
1392
1395 self.WIDTH = 820
1393 self.WIDTH = 820
1396 self.HEIGHT = 200
1394 self.HEIGHT = 200
1397 self.WIDTHPROF = 120
1395 self.WIDTHPROF = 120
1398 self.HEIGHTPROF = 0
1396 self.HEIGHTPROF = 0
1399 self.counter_imagwr = 0
1397 self.counter_imagwr = 0
1400 self.xdata = None
1398 self.xdata = None
1401 self.ydata = None
1399 self.ydata = None
1402
1400
1403 def getSubplots(self):
1401 def getSubplots(self):
1404
1402
1405 ncol = 1
1403 ncol = 1
1406 nrow = 1
1404 nrow = 1
1407
1405
1408 return nrow, ncol
1406 return nrow, ncol
1409
1407
1410 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1408 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1411
1409
1412 self.__showprofile = showprofile
1410 self.__showprofile = showprofile
1413 self.nplots = nplots
1411 self.nplots = nplots
1414
1412
1415 ncolspan = 7
1413 ncolspan = 7
1416 colspan = 6
1414 colspan = 6
1417 self.__nsubplots = 2
1415 self.__nsubplots = 2
1418
1416
1419 self.createFigure(id = id,
1417 self.createFigure(id = id,
1420 wintitle = wintitle,
1418 wintitle = wintitle,
1421 widthplot = self.WIDTH+self.WIDTHPROF,
1419 widthplot = self.WIDTH+self.WIDTHPROF,
1422 heightplot = self.HEIGHT+self.HEIGHTPROF,
1420 heightplot = self.HEIGHT+self.HEIGHTPROF,
1423 show = show)
1421 show = show)
1424
1422
1425 nrow, ncol = self.getSubplots()
1423 nrow, ncol = self.getSubplots()
1426
1424
1427 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1425 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1428
1426
1429
1427
1430 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
1428 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
1431 xmin=None, xmax=None, ymin=None, ymax=None,
1429 xmin=None, xmax=None, ymin=None, ymax=None,
1432 timerange=None,
1430 timerange=None,
1433 save=False, figpath='./', figfile=None, ftp=False, wr_period=1, show=True):
1431 save=False, figpath='./', figfile=None, ftp=False, wr_period=1, show=True):
1434
1432
1435 if channelList == None:
1433 if channelList == None:
1436 channelIndexList = dataOut.channelIndexList
1434 channelIndexList = dataOut.channelIndexList
1437 channelList = dataOut.channelList
1435 channelList = dataOut.channelList
1438 else:
1436 else:
1439 channelIndexList = []
1437 channelIndexList = []
1440 for channel in channelList:
1438 for channel in channelList:
1441 if channel not in dataOut.channelList:
1439 if channel not in dataOut.channelList:
1442 raise ValueError, "Channel %d is not in dataOut.channelList"
1440 raise ValueError, "Channel %d is not in dataOut.channelList"
1443 channelIndexList.append(dataOut.channelList.index(channel))
1441 channelIndexList.append(dataOut.channelList.index(channel))
1444
1442
1445 if timerange != None:
1443 if timerange != None:
1446 self.timerange = timerange
1444 self.timerange = timerange
1447
1445
1448 tmin = None
1446 tmin = None
1449 tmax = None
1447 tmax = None
1450 x = dataOut.getTimeRange()
1448 x = dataOut.getTimeRange()
1451 y = dataOut.getHeiRange()
1449 y = dataOut.getHeiRange()
1452
1450
1453 factor = 1
1451 factor = 1
1454 data = dataOut.data_spc/factor
1452 data = dataOut.data_spc/factor
1455 data = numpy.average(data,axis=1)
1453 data = numpy.average(data,axis=1)
1456 datadB = 10*numpy.log10(data)
1454 datadB = 10*numpy.log10(data)
1457
1455
1458 # factor = dataOut.normFactor
1456 # factor = dataOut.normFactor
1459 # noise = dataOut.getNoise()/factor
1457 # noise = dataOut.getNoise()/factor
1460 # noisedB = 10*numpy.log10(noise)
1458 # noisedB = 10*numpy.log10(noise)
1461
1459
1462 #thisDatetime = dataOut.datatime
1460 #thisDatetime = dataOut.datatime
1463 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
1461 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
1464 title = wintitle + " RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
1462 title = wintitle + " RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
1465 xlabel = "Local Time"
1463 xlabel = "Local Time"
1466 ylabel = "Intensity (dB)"
1464 ylabel = "Intensity (dB)"
1467
1465
1468 if not self.__isConfig:
1466 if not self.__isConfig:
1469
1467
1470 nplots = 1
1468 nplots = 1
1471
1469
1472 self.setup(id=id,
1470 self.setup(id=id,
1473 nplots=nplots,
1471 nplots=nplots,
1474 wintitle=wintitle,
1472 wintitle=wintitle,
1475 showprofile=showprofile,
1473 showprofile=showprofile,
1476 show=show)
1474 show=show)
1477
1475
1478 tmin, tmax = self.getTimeLim(x, xmin, xmax)
1476 tmin, tmax = self.getTimeLim(x, xmin, xmax)
1479 if ymin == None: ymin = numpy.nanmin(datadB)
1477 if ymin == None: ymin = numpy.nanmin(datadB)
1480 if ymax == None: ymax = numpy.nanmax(datadB)
1478 if ymax == None: ymax = numpy.nanmax(datadB)
1481
1479
1482 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1480 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1483 self.__isConfig = True
1481 self.__isConfig = True
1484
1482
1485 self.xdata = numpy.array([])
1483 self.xdata = numpy.array([])
1486 self.ydata = numpy.array([])
1484 self.ydata = numpy.array([])
1487
1485
1488 self.setWinTitle(title)
1486 self.setWinTitle(title)
1489
1487
1490
1488
1491 # title = "RTI %s" %(thisDatetime.strftime("%d-%b-%Y"))
1489 # title = "RTI %s" %(thisDatetime.strftime("%d-%b-%Y"))
1492 title = "RTI-Noise - %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
1490 title = "RTI-Noise - %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
1493
1491
1494 legendlabels = ["channel %d"%idchannel for idchannel in channelList]
1492 legendlabels = ["channel %d"%idchannel for idchannel in channelList]
1495 axes = self.axesList[0]
1493 axes = self.axesList[0]
1496
1494
1497 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1495 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1498
1496
1499 if len(self.ydata)==0:
1497 if len(self.ydata)==0:
1500 self.ydata = datadB[channelIndexList].reshape(-1,1)
1498 self.ydata = datadB[channelIndexList].reshape(-1,1)
1501 else:
1499 else:
1502 self.ydata = numpy.hstack((self.ydata, datadB[channelIndexList].reshape(-1,1)))
1500 self.ydata = numpy.hstack((self.ydata, datadB[channelIndexList].reshape(-1,1)))
1503
1501
1504
1502
1505 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1503 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1506 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
1504 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
1507 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='.', markersize=8, linestyle="solid", grid='both',
1505 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='.', markersize=8, linestyle="solid", grid='both',
1508 XAxisAsTime=True
1506 XAxisAsTime=True
1509 )
1507 )
1510
1508
1511 self.draw()
1509 self.draw()
1512
1510
1513 if save:
1511 if save:
1514
1512
1515 if figfile == None:
1513 if figfile == None:
1516 figfile = self.getFilename(name = self.name)
1514 figfile = self.getFilename(name = self.name)
1517
1515
1518 self.saveFigure(figpath, figfile)
1516 self.saveFigure(figpath, figfile)
1519
1517
1520 self.counter_imagwr += 1
1518 self.counter_imagwr += 1
1521 if (ftp and (self.counter_imagwr==wr_period)):
1519 if (ftp and (self.counter_imagwr==wr_period)):
1522 figfilename = os.path.join(figpath,figfile)
1520 figfilename = os.path.join(figpath,figfile)
1523 self.sendByFTP(figfilename)
1521 self.sendByFTP(figfilename)
1524 self.counter_imagwr = 0
1522 self.counter_imagwr = 0
1525
1523
1526 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
1524 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
1527 self.__isConfig = False
1525 self.__isConfig = False
1528 del self.xdata
1526 del self.xdata
1529 del self.ydata
1527 del self.ydata
1530
1528
1531
1529
1532 No newline at end of file
1530
General Comments 0
You need to be logged in to leave comments. Login now