##// END OF EJS Templates
schain-jc
RSS
Bug plotting RTI fixed for jroplot_heispectra, jroplot_parameters, jroplot_spectra
Miguel Valdez -
r567:753c4d780d0c
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,326 +1,326
1 1 '''
2 2
3 3 @author: Daniel Suarez
4 4 '''
5 5
6 6 import os
7 7 import datetime
8 8 import numpy
9 9
10 10 from figure import Figure, isRealtime
11 11
12 12 class SpectraHeisScope(Figure):
13 13
14 14
15 15 isConfig = None
16 16 __nsubplots = None
17 17
18 18 WIDTHPROF = None
19 19 HEIGHTPROF = None
20 20 PREFIX = 'spc'
21 21
22 22 def __init__(self):
23 23
24 24 self.isConfig = False
25 25 self.__nsubplots = 1
26 26
27 27 self.WIDTH = 230
28 28 self.HEIGHT = 250
29 29 self.WIDTHPROF = 120
30 30 self.HEIGHTPROF = 0
31 31 self.counter_imagwr = 0
32 32
33 33 def getSubplots(self):
34 34
35 35 ncol = int(numpy.sqrt(self.nplots)+0.9)
36 36 nrow = int(self.nplots*1./ncol + 0.9)
37 37
38 38 return nrow, ncol
39 39
40 40 def setup(self, id, nplots, wintitle, show):
41 41
42 42 showprofile = False
43 43 self.__showprofile = showprofile
44 44 self.nplots = nplots
45 45
46 46 ncolspan = 1
47 47 colspan = 1
48 48 if showprofile:
49 49 ncolspan = 3
50 50 colspan = 2
51 51 self.__nsubplots = 2
52 52
53 53 self.createFigure(id = id,
54 54 wintitle = wintitle,
55 55 widthplot = self.WIDTH + self.WIDTHPROF,
56 56 heightplot = self.HEIGHT + self.HEIGHTPROF,
57 57 show = show)
58 58
59 59 nrow, ncol = self.getSubplots()
60 60
61 61 counter = 0
62 62 for y in range(nrow):
63 63 for x in range(ncol):
64 64
65 65 if counter >= self.nplots:
66 66 break
67 67
68 68 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
69 69
70 70 if showprofile:
71 71 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
72 72
73 73 counter += 1
74 74
75 75
76 76 def run(self, dataOut, id, wintitle="", channelList=None,
77 77 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
78 78 figpath='', figfile=None, ftp=False, wr_period=1, show=True,
79 79 server=None, folder=None, username=None, password=None):
80 80
81 81 """
82 82
83 83 Input:
84 84 dataOut :
85 85 id :
86 86 wintitle :
87 87 channelList :
88 88 xmin : None,
89 89 xmax : None,
90 90 ymin : None,
91 91 ymax : None,
92 92 """
93 93
94 94 if dataOut.realtime:
95 95 if not(isRealtime(utcdatatime = dataOut.utctime)):
96 96 print 'Skipping this plot function'
97 97 return
98 98
99 99 if channelList == None:
100 100 channelIndexList = dataOut.channelIndexList
101 101 else:
102 102 channelIndexList = []
103 103 for channel in channelList:
104 104 if channel not in dataOut.channelList:
105 105 raise ValueError, "Channel %d is not in dataOut.channelList"
106 106 channelIndexList.append(dataOut.channelList.index(channel))
107 107
108 108 # x = dataOut.heightList
109 109 c = 3E8
110 110 deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
111 111 #deberia cambiar para el caso de 1Mhz y 100KHz
112 112 x = numpy.arange(-1*dataOut.nHeights/2.,dataOut.nHeights/2.)*(c/(2*deltaHeight*dataOut.nHeights*1000))
113 113 #para 1Mhz descomentar la siguiente linea
114 114 #x= x/(10000.0)
115 115 # y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
116 116 # y = y.real
117 117 factor = dataOut.normFactor
118 118 data = dataOut.data_spc / factor
119 119 datadB = 10.*numpy.log10(data)
120 120 y = datadB
121 121
122 122 #thisDatetime = dataOut.datatime
123 123 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
124 124 title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
125 125 xlabel = ""
126 126 #para 1Mhz descomentar la siguiente linea
127 127 #xlabel = "Frequency x 10000"
128 128 ylabel = "Intensity (dB)"
129 129
130 130 if not self.isConfig:
131 131 nplots = len(channelIndexList)
132 132
133 133 self.setup(id=id,
134 134 nplots=nplots,
135 135 wintitle=wintitle,
136 136 show=show)
137 137
138 138 if xmin == None: xmin = numpy.nanmin(x)
139 139 if xmax == None: xmax = numpy.nanmax(x)
140 140 if ymin == None: ymin = numpy.nanmin(y)
141 141 if ymax == None: ymax = numpy.nanmax(y)
142 142
143 143 self.isConfig = True
144 144
145 145 self.setWinTitle(title)
146 146
147 147 for i in range(len(self.axesList)):
148 148 ychannel = y[i,:]
149 149 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
150 150 title = "Channel %d: %4.2fdB: %s" %(i, numpy.max(ychannel), str_datetime)
151 151 axes = self.axesList[i]
152 152 axes.pline(x, ychannel,
153 153 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
154 154 xlabel=xlabel, ylabel=ylabel, title=title, grid='both')
155 155
156 156
157 157 self.draw()
158 158
159 159 if figfile == None:
160 160 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
161 161 figfile = self.getFilename(name = str_datetime)
162 162
163 163 if figpath != '':
164 164 self.counter_imagwr += 1
165 165 if (self.counter_imagwr>=wr_period):
166 166 # store png plot to local folder
167 167 self.saveFigure(figpath, figfile)
168 168 # store png plot to FTP server according to RT-Web format
169 169 #name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
170 170 #ftp_filename = os.path.join(figpath, name)
171 171 #self.saveFigure(figpath, ftp_filename)
172 172 self.counter_imagwr = 0
173 173
174 174 class RTIfromSpectraHeis(Figure):
175 175
176 176 isConfig = None
177 177 __nsubplots = None
178 178
179 179 PREFIX = 'rtinoise'
180 180
181 181 def __init__(self):
182 182
183 183 self.timerange = 24*60*60
184 184 self.isConfig = False
185 185 self.__nsubplots = 1
186 186
187 187 self.WIDTH = 820
188 188 self.HEIGHT = 200
189 189 self.WIDTHPROF = 120
190 190 self.HEIGHTPROF = 0
191 191 self.counter_imagwr = 0
192 192 self.xdata = None
193 193 self.ydata = None
194 194 self.figfile = None
195 195
196 196 def getSubplots(self):
197 197
198 198 ncol = 1
199 199 nrow = 1
200 200
201 201 return nrow, ncol
202 202
203 203 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
204 204
205 205 self.__showprofile = showprofile
206 206 self.nplots = nplots
207 207
208 208 ncolspan = 7
209 209 colspan = 6
210 210 self.__nsubplots = 2
211 211
212 212 self.createFigure(id = id,
213 213 wintitle = wintitle,
214 214 widthplot = self.WIDTH+self.WIDTHPROF,
215 215 heightplot = self.HEIGHT+self.HEIGHTPROF,
216 216 show = show)
217 217
218 218 nrow, ncol = self.getSubplots()
219 219
220 220 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
221 221
222 222
223 223 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
224 224 xmin=None, xmax=None, ymin=None, ymax=None,
225 225 timerange=None,
226 226 save=False, figpath='', figfile=None, ftp=False, wr_period=1, show=True,
227 227 server=None, folder=None, username=None, password=None):
228 228
229 229 if channelList == None:
230 230 channelIndexList = dataOut.channelIndexList
231 231 channelList = dataOut.channelList
232 232 else:
233 233 channelIndexList = []
234 234 for channel in channelList:
235 235 if channel not in dataOut.channelList:
236 236 raise ValueError, "Channel %d is not in dataOut.channelList"
237 237 channelIndexList.append(dataOut.channelList.index(channel))
238 238
239 239 if timerange != None:
240 240 self.timerange = timerange
241 241
242 242 tmin = None
243 243 tmax = None
244 244 x = dataOut.getTimeRange()
245 245 y = dataOut.getHeiRange()
246 246
247 247 factor = dataOut.normFactor
248 248 data = dataOut.data_spc / factor
249 249 data = numpy.average(data,axis=1)
250 250 datadB = 10*numpy.log10(data)
251 251
252 252 # factor = dataOut.normFactor
253 253 # noise = dataOut.getNoise()/factor
254 254 # noisedB = 10*numpy.log10(noise)
255 255
256 256 #thisDatetime = dataOut.datatime
257 257 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
258 258 title = wintitle + " RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
259 259 xlabel = "Local Time"
260 260 ylabel = "Intensity (dB)"
261 261
262 262 if not self.isConfig:
263 263
264 264 nplots = 1
265 265
266 266 self.setup(id=id,
267 267 nplots=nplots,
268 268 wintitle=wintitle,
269 269 showprofile=showprofile,
270 270 show=show)
271 271
272 tmin, tmax = self.getTimeLim(x, xmin, xmax, timezone = dataOut.timezone)
272 tmin, tmax = self.getTimeLim(x, xmin, xmax)
273 273 if ymin == None: ymin = numpy.nanmin(datadB)
274 274 if ymax == None: ymax = numpy.nanmax(datadB)
275 275
276 276 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
277 277 self.isConfig = True
278 278 self.figfile = figfile
279 279 self.xdata = numpy.array([])
280 280 self.ydata = numpy.array([])
281 281
282 282 self.setWinTitle(title)
283 283
284 284
285 285 # title = "RTI %s" %(thisDatetime.strftime("%d-%b-%Y"))
286 286 title = "RTI - %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
287 287
288 288 legendlabels = ["channel %d"%idchannel for idchannel in channelList]
289 289 axes = self.axesList[0]
290 290
291 291 self.xdata = numpy.hstack((self.xdata, x[0:1]))
292 292
293 293 if len(self.ydata)==0:
294 294 self.ydata = datadB[channelIndexList].reshape(-1,1)
295 295 else:
296 296 self.ydata = numpy.hstack((self.ydata, datadB[channelIndexList].reshape(-1,1)))
297 297
298 298
299 299 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
300 300 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
301 301 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='.', markersize=8, linestyle="solid", grid='both',
302 302 XAxisAsTime=True
303 303 )
304 304
305 305 self.draw()
306 306
307 307 if x[1] >= self.axesList[0].xmax:
308 308 self.counter_imagwr = wr_period
309 309 del self.xdata
310 310 del self.ydata
311 311 self.__isConfig = False
312 312
313 313 if self.figfile == None:
314 314 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
315 315 self.figfile = self.getFilename(name = str_datetime)
316 316
317 317 if figpath != '':
318 318 self.counter_imagwr += 1
319 319 if (self.counter_imagwr>=wr_period):
320 320 # store png plot to local folder
321 321 self.saveFigure(figpath, self.figfile)
322 322 # store png plot to FTP server according to RT-Web format
323 323 #name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
324 324 #ftp_filename = os.path.join(figpath, name)
325 325 #self.saveFigure(figpath, ftp_filename)
326 326 self.counter_imagwr = 0
Show file before | Show file after | Hide comments
@@ -1,1195 +1,1195
1 1 import os
2 2 import datetime
3 3 import numpy
4 4
5 5 from figure import Figure, isRealtime
6 6
7 7 class MomentsPlot(Figure):
8 8
9 9 isConfig = None
10 10 __nsubplots = None
11 11
12 12 WIDTHPROF = None
13 13 HEIGHTPROF = None
14 14 PREFIX = 'prm'
15 15
16 16 def __init__(self):
17 17
18 18 self.isConfig = False
19 19 self.__nsubplots = 1
20 20
21 21 self.WIDTH = 280
22 22 self.HEIGHT = 250
23 23 self.WIDTHPROF = 120
24 24 self.HEIGHTPROF = 0
25 25 self.counter_imagwr = 0
26 26
27 27 self.PLOT_CODE = 1
28 28 self.FTP_WEI = None
29 29 self.EXP_CODE = None
30 30 self.SUB_EXP_CODE = None
31 31 self.PLOT_POS = None
32 32
33 33 def getSubplots(self):
34 34
35 35 ncol = int(numpy.sqrt(self.nplots)+0.9)
36 36 nrow = int(self.nplots*1./ncol + 0.9)
37 37
38 38 return nrow, ncol
39 39
40 40 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
41 41
42 42 self.__showprofile = showprofile
43 43 self.nplots = nplots
44 44
45 45 ncolspan = 1
46 46 colspan = 1
47 47 if showprofile:
48 48 ncolspan = 3
49 49 colspan = 2
50 50 self.__nsubplots = 2
51 51
52 52 self.createFigure(id = id,
53 53 wintitle = wintitle,
54 54 widthplot = self.WIDTH + self.WIDTHPROF,
55 55 heightplot = self.HEIGHT + self.HEIGHTPROF,
56 56 show=show)
57 57
58 58 nrow, ncol = self.getSubplots()
59 59
60 60 counter = 0
61 61 for y in range(nrow):
62 62 for x in range(ncol):
63 63
64 64 if counter >= self.nplots:
65 65 break
66 66
67 67 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
68 68
69 69 if showprofile:
70 70 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
71 71
72 72 counter += 1
73 73
74 74 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
75 75 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
76 76 save=False, figpath='', figfile=None, show=True, ftp=False, wr_period=1,
77 77 server=None, folder=None, username=None, password=None,
78 78 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
79 79
80 80 """
81 81
82 82 Input:
83 83 dataOut :
84 84 id :
85 85 wintitle :
86 86 channelList :
87 87 showProfile :
88 88 xmin : None,
89 89 xmax : None,
90 90 ymin : None,
91 91 ymax : None,
92 92 zmin : None,
93 93 zmax : None
94 94 """
95 95
96 96 if dataOut.flagNoData:
97 97 return None
98 98
99 99 if realtime:
100 100 if not(isRealtime(utcdatatime = dataOut.utctime)):
101 101 print 'Skipping this plot function'
102 102 return
103 103
104 104 if channelList == None:
105 105 channelIndexList = dataOut.channelIndexList
106 106 else:
107 107 channelIndexList = []
108 108 for channel in channelList:
109 109 if channel not in dataOut.channelList:
110 110 raise ValueError, "Channel %d is not in dataOut.channelList"
111 111 channelIndexList.append(dataOut.channelList.index(channel))
112 112
113 113 factor = dataOut.normFactor
114 114 x = dataOut.abscissaList
115 115 y = dataOut.heightList
116 116
117 117 z = dataOut.data_pre[channelIndexList,:,:]/factor
118 118 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
119 119 avg = numpy.average(z, axis=1)
120 120 noise = dataOut.noise/factor
121 121
122 122 zdB = 10*numpy.log10(z)
123 123 avgdB = 10*numpy.log10(avg)
124 124 noisedB = 10*numpy.log10(noise)
125 125
126 126 #thisDatetime = dataOut.datatime
127 127 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
128 128 title = wintitle + " Parameters"
129 129 xlabel = "Velocity (m/s)"
130 130 ylabel = "Range (Km)"
131 131
132 132 if not self.isConfig:
133 133
134 134 nplots = len(channelIndexList)
135 135
136 136 self.setup(id=id,
137 137 nplots=nplots,
138 138 wintitle=wintitle,
139 139 showprofile=showprofile,
140 140 show=show)
141 141
142 142 if xmin == None: xmin = numpy.nanmin(x)
143 143 if xmax == None: xmax = numpy.nanmax(x)
144 144 if ymin == None: ymin = numpy.nanmin(y)
145 145 if ymax == None: ymax = numpy.nanmax(y)
146 146 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
147 147 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
148 148
149 149 self.FTP_WEI = ftp_wei
150 150 self.EXP_CODE = exp_code
151 151 self.SUB_EXP_CODE = sub_exp_code
152 152 self.PLOT_POS = plot_pos
153 153
154 154 self.isConfig = True
155 155
156 156 self.setWinTitle(title)
157 157
158 158 for i in range(self.nplots):
159 159 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
160 160 title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i]+1, noisedB[i], str_datetime)
161 161 axes = self.axesList[i*self.__nsubplots]
162 162 axes.pcolor(x, y, zdB[i,:,:],
163 163 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
164 164 xlabel=xlabel, ylabel=ylabel, title=title,
165 165 ticksize=9, cblabel='')
166 166 #Mean Line
167 167 mean = dataOut.data_param[i, 1, :]
168 168 axes.addpline(mean, y, idline=0, color="black", linestyle="solid", lw=1)
169 169
170 170 if self.__showprofile:
171 171 axes = self.axesList[i*self.__nsubplots +1]
172 172 axes.pline(avgdB[i], y,
173 173 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
174 174 xlabel='dB', ylabel='', title='',
175 175 ytick_visible=False,
176 176 grid='x')
177 177
178 178 noiseline = numpy.repeat(noisedB[i], len(y))
179 179 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
180 180
181 181 self.draw()
182 182
183 183 if figfile == None:
184 184 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
185 185 figfile = self.getFilename(name = str_datetime)
186 186
187 187 if figpath != '':
188 188 self.counter_imagwr += 1
189 189 if (self.counter_imagwr>=wr_period):
190 190 # store png plot to local folder
191 191 self.saveFigure(figpath, figfile)
192 192 # store png plot to FTP server according to RT-Web format
193 193 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
194 194 ftp_filename = os.path.join(figpath, name)
195 195 self.saveFigure(figpath, ftp_filename)
196 196 self.counter_imagwr = 0
197 197
198 198 class SkyMapPlot(Figure):
199 199
200 200 __isConfig = None
201 201 __nsubplots = None
202 202
203 203 WIDTHPROF = None
204 204 HEIGHTPROF = None
205 205 PREFIX = 'prm'
206 206
207 207 def __init__(self):
208 208
209 209 self.__isConfig = False
210 210 self.__nsubplots = 1
211 211
212 212 # self.WIDTH = 280
213 213 # self.HEIGHT = 250
214 214 self.WIDTH = 600
215 215 self.HEIGHT = 600
216 216 self.WIDTHPROF = 120
217 217 self.HEIGHTPROF = 0
218 218 self.counter_imagwr = 0
219 219
220 220 self.PLOT_CODE = 1
221 221 self.FTP_WEI = None
222 222 self.EXP_CODE = None
223 223 self.SUB_EXP_CODE = None
224 224 self.PLOT_POS = None
225 225
226 226 def getSubplots(self):
227 227
228 228 ncol = int(numpy.sqrt(self.nplots)+0.9)
229 229 nrow = int(self.nplots*1./ncol + 0.9)
230 230
231 231 return nrow, ncol
232 232
233 233 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
234 234
235 235 self.__showprofile = showprofile
236 236 self.nplots = nplots
237 237
238 238 ncolspan = 1
239 239 colspan = 1
240 240
241 241 self.createFigure(id = id,
242 242 wintitle = wintitle,
243 243 widthplot = self.WIDTH, #+ self.WIDTHPROF,
244 244 heightplot = self.HEIGHT,# + self.HEIGHTPROF,
245 245 show=show)
246 246
247 247 nrow, ncol = 1,1
248 248 counter = 0
249 249 x = 0
250 250 y = 0
251 251 self.addAxes(1, 1, 0, 0, 1, 1, True)
252 252
253 253 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
254 254 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
255 255 save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
256 256 server=None, folder=None, username=None, password=None,
257 257 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
258 258
259 259 """
260 260
261 261 Input:
262 262 dataOut :
263 263 id :
264 264 wintitle :
265 265 channelList :
266 266 showProfile :
267 267 xmin : None,
268 268 xmax : None,
269 269 ymin : None,
270 270 ymax : None,
271 271 zmin : None,
272 272 zmax : None
273 273 """
274 274
275 275 arrayParameters = dataOut.data_param
276 276 error = arrayParameters[:,-1]
277 277 indValid = numpy.where(error == 0)[0]
278 278 finalMeteor = arrayParameters[indValid,:]
279 279 finalAzimuth = finalMeteor[:,4]
280 280 finalZenith = finalMeteor[:,5]
281 281
282 282 x = finalAzimuth*numpy.pi/180
283 283 y = finalZenith
284 284
285 285
286 286 #thisDatetime = dataOut.datatime
287 287 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
288 288 title = wintitle + " Parameters"
289 289 xlabel = "Zonal Zenith Angle (deg) "
290 290 ylabel = "Meridional Zenith Angle (deg)"
291 291
292 292 if not self.__isConfig:
293 293
294 294 nplots = 1
295 295
296 296 self.setup(id=id,
297 297 nplots=nplots,
298 298 wintitle=wintitle,
299 299 showprofile=showprofile,
300 300 show=show)
301 301
302 302 self.FTP_WEI = ftp_wei
303 303 self.EXP_CODE = exp_code
304 304 self.SUB_EXP_CODE = sub_exp_code
305 305 self.PLOT_POS = plot_pos
306 306 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
307 307 self.firstdate = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
308 308 self.__isConfig = True
309 309
310 310 self.setWinTitle(title)
311 311
312 312 i = 0
313 313 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
314 314
315 315 axes = self.axesList[i*self.__nsubplots]
316 316 nevents = axes.x_buffer.shape[0] + x.shape[0]
317 317 title = "Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n" %(self.firstdate,str_datetime,nevents)
318 318 axes.polar(x, y,
319 319 title=title, xlabel=xlabel, ylabel=ylabel,
320 320 ticksize=9, cblabel='')
321 321
322 322 self.draw()
323 323
324 324 if save:
325 325
326 326 self.counter_imagwr += 1
327 327 if (self.counter_imagwr==wr_period):
328 328
329 329 if figfile == None:
330 330 figfile = self.getFilename(name = self.name)
331 331 self.saveFigure(figpath, figfile)
332 332
333 333 if ftp:
334 334 #provisionalmente envia archivos en el formato de la web en tiempo real
335 335 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
336 336 path = '%s%03d' %(self.PREFIX, self.id)
337 337 ftp_file = os.path.join(path,'ftp','%s.png'%name)
338 338 self.saveFigure(figpath, ftp_file)
339 339 ftp_filename = os.path.join(figpath,ftp_file)
340 340
341 341
342 342 try:
343 343 self.sendByFTP(ftp_filename, server, folder, username, password)
344 344 except:
345 345 self.counter_imagwr = 0
346 346 raise ValueError, 'Error FTP'
347 347
348 348 self.counter_imagwr = 0
349 349
350 350
351 351 class WindProfilerPlot(Figure):
352 352
353 353 __isConfig = None
354 354 __nsubplots = None
355 355
356 356 WIDTHPROF = None
357 357 HEIGHTPROF = None
358 358 PREFIX = 'wind'
359 359
360 360 def __init__(self):
361 361
362 362 self.timerange = 2*60*60
363 363 self.__isConfig = False
364 364 self.__nsubplots = 1
365 365
366 366 self.WIDTH = 800
367 367 self.HEIGHT = 150
368 368 self.WIDTHPROF = 120
369 369 self.HEIGHTPROF = 0
370 370 self.counter_imagwr = 0
371 371
372 372 self.PLOT_CODE = 0
373 373 self.FTP_WEI = None
374 374 self.EXP_CODE = None
375 375 self.SUB_EXP_CODE = None
376 376 self.PLOT_POS = None
377 377 self.tmin = None
378 378 self.tmax = None
379 379
380 380 self.xmin = None
381 381 self.xmax = None
382 382
383 383 self.figfile = None
384 384
385 385 def getSubplots(self):
386 386
387 387 ncol = 1
388 388 nrow = self.nplots
389 389
390 390 return nrow, ncol
391 391
392 392 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
393 393
394 394 self.__showprofile = showprofile
395 395 self.nplots = nplots
396 396
397 397 ncolspan = 1
398 398 colspan = 1
399 399
400 400 self.createFigure(id = id,
401 401 wintitle = wintitle,
402 402 widthplot = self.WIDTH + self.WIDTHPROF,
403 403 heightplot = self.HEIGHT + self.HEIGHTPROF,
404 404 show=show)
405 405
406 406 nrow, ncol = self.getSubplots()
407 407
408 408 counter = 0
409 409 for y in range(nrow):
410 410 if counter >= self.nplots:
411 411 break
412 412
413 413 self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
414 414 counter += 1
415 415
416 416 def run(self, dataOut, id, wintitle="", channelList=None,
417 417 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
418 418 zmax_ver = None, zmin_ver = None, SNRmin = None, SNRmax = None,
419 419 timerange=None, SNRthresh = None,
420 420 save=False, figpath='', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
421 421 server=None, folder=None, username=None, password=None,
422 422 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
423 423 """
424 424
425 425 Input:
426 426 dataOut :
427 427 id :
428 428 wintitle :
429 429 channelList :
430 430 showProfile :
431 431 xmin : None,
432 432 xmax : None,
433 433 ymin : None,
434 434 ymax : None,
435 435 zmin : None,
436 436 zmax : None
437 437 """
438 438
439 439 if channelList == None:
440 440 channelIndexList = dataOut.channelIndexList
441 441 else:
442 442 channelIndexList = []
443 443 for channel in channelList:
444 444 if channel not in dataOut.channelList:
445 445 raise ValueError, "Channel %d is not in dataOut.channelList"
446 446 channelIndexList.append(dataOut.channelList.index(channel))
447 447
448 448 if timerange != None:
449 449 self.timerange = timerange
450 450
451 451 tmin = None
452 452 tmax = None
453 453
454 454 x = dataOut.getTimeRange1()
455 455 # y = dataOut.heightList
456 456 y = dataOut.heightList
457 457
458 458 z = dataOut.data_output.copy()
459 459 nplots = z.shape[0] #Number of wind dimensions estimated
460 460 nplotsw = nplots
461 461
462 462 #If there is a SNR function defined
463 463 if dataOut.data_SNR != None:
464 464 nplots += 1
465 465 SNR = dataOut.data_SNR
466 466 SNRavg = numpy.average(SNR, axis=0)
467 467
468 468 SNRdB = 10*numpy.log10(SNR)
469 469 SNRavgdB = 10*numpy.log10(SNRavg)
470 470
471 471 if SNRthresh == None: SNRthresh = -5.0
472 472 ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
473 473
474 474 for i in range(nplotsw):
475 475 z[i,ind] = numpy.nan
476 476
477 477
478 478 showprofile = False
479 479 # thisDatetime = dataOut.datatime
480 480 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
481 481 title = wintitle + "Wind"
482 482 xlabel = ""
483 483 ylabel = "Range (Km)"
484 484
485 485 if not self.__isConfig:
486 486
487 487 self.setup(id=id,
488 488 nplots=nplots,
489 489 wintitle=wintitle,
490 490 showprofile=showprofile,
491 491 show=show)
492 492
493 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
493 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
494 494
495 495 if ymin == None: ymin = numpy.nanmin(y)
496 496 if ymax == None: ymax = numpy.nanmax(y)
497 497
498 498 if zmax == None: zmax = numpy.nanmax(abs(z[range(2),:]))
499 499 #if numpy.isnan(zmax): zmax = 50
500 500 if zmin == None: zmin = -zmax
501 501
502 502 if nplotsw == 3:
503 503 if zmax_ver == None: zmax_ver = numpy.nanmax(abs(z[2,:]))
504 504 if zmin_ver == None: zmin_ver = -zmax_ver
505 505
506 506 if dataOut.data_SNR != None:
507 507 if SNRmin == None: SNRmin = numpy.nanmin(SNRavgdB)
508 508 if SNRmax == None: SNRmax = numpy.nanmax(SNRavgdB)
509 509
510 510 self.FTP_WEI = ftp_wei
511 511 self.EXP_CODE = exp_code
512 512 self.SUB_EXP_CODE = sub_exp_code
513 513 self.PLOT_POS = plot_pos
514 514
515 515 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
516 516 self.__isConfig = True
517 517
518 518
519 519 self.setWinTitle(title)
520 520
521 521 if ((self.xmax - x[1]) < (x[1]-x[0])):
522 522 x[1] = self.xmax
523 523
524 524 strWind = ['Zonal', 'Meridional', 'Vertical']
525 525 strCb = ['Velocity (m/s)','Velocity (m/s)','Velocity (cm/s)']
526 526 zmaxVector = [zmax, zmax, zmax_ver]
527 527 zminVector = [zmin, zmin, zmin_ver]
528 528 windFactor = [1,1,100]
529 529
530 530 for i in range(nplotsw):
531 531
532 532 title = "%s Wind: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
533 533 axes = self.axesList[i*self.__nsubplots]
534 534
535 535 z1 = z[i,:].reshape((1,-1))*windFactor[i]
536 536
537 537 axes.pcolorbuffer(x, y, z1,
538 538 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
539 539 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
540 540 ticksize=9, cblabel=strCb[i], cbsize="1%", colormap="RdBu_r" )
541 541
542 542 if dataOut.data_SNR != None:
543 543 i += 1
544 544 title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
545 545 axes = self.axesList[i*self.__nsubplots]
546 546
547 547 SNRavgdB = SNRavgdB.reshape((1,-1))
548 548
549 549 axes.pcolorbuffer(x, y, SNRavgdB,
550 550 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
551 551 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
552 552 ticksize=9, cblabel='', cbsize="1%", colormap="jet")
553 553
554 554 self.draw()
555 555
556 556 if self.figfile == None:
557 557 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
558 558 self.figfile = self.getFilename(name = str_datetime)
559 559
560 560 if figpath != '':
561 561
562 562 self.counter_imagwr += 1
563 563 if (self.counter_imagwr>=wr_period):
564 564 # store png plot to local folder
565 565 self.saveFigure(figpath, self.figfile)
566 566 # store png plot to FTP server according to RT-Web format
567 567 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
568 568 ftp_filename = os.path.join(figpath, name)
569 569 self.saveFigure(figpath, ftp_filename)
570 570
571 571 self.counter_imagwr = 0
572 572
573 573 if x[1] >= self.axesList[0].xmax:
574 574 self.counter_imagwr = wr_period
575 575 self.__isConfig = False
576 576 self.figfile = None
577 577
578 578
579 579 class ParametersPlot(Figure):
580 580
581 581 __isConfig = None
582 582 __nsubplots = None
583 583
584 584 WIDTHPROF = None
585 585 HEIGHTPROF = None
586 586 PREFIX = 'prm'
587 587
588 588 def __init__(self):
589 589
590 590 self.timerange = 2*60*60
591 591 self.__isConfig = False
592 592 self.__nsubplots = 1
593 593
594 594 self.WIDTH = 800
595 595 self.HEIGHT = 150
596 596 self.WIDTHPROF = 120
597 597 self.HEIGHTPROF = 0
598 598 self.counter_imagwr = 0
599 599
600 600 self.PLOT_CODE = 0
601 601 self.FTP_WEI = None
602 602 self.EXP_CODE = None
603 603 self.SUB_EXP_CODE = None
604 604 self.PLOT_POS = None
605 605 self.tmin = None
606 606 self.tmax = None
607 607
608 608 self.xmin = None
609 609 self.xmax = None
610 610
611 611 self.figfile = None
612 612
613 613 def getSubplots(self):
614 614
615 615 ncol = 1
616 616 nrow = self.nplots
617 617
618 618 return nrow, ncol
619 619
620 620 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
621 621
622 622 self.__showprofile = showprofile
623 623 self.nplots = nplots
624 624
625 625 ncolspan = 1
626 626 colspan = 1
627 627
628 628 self.createFigure(id = id,
629 629 wintitle = wintitle,
630 630 widthplot = self.WIDTH + self.WIDTHPROF,
631 631 heightplot = self.HEIGHT + self.HEIGHTPROF,
632 632 show=show)
633 633
634 634 nrow, ncol = self.getSubplots()
635 635
636 636 counter = 0
637 637 for y in range(nrow):
638 638 for x in range(ncol):
639 639
640 640 if counter >= self.nplots:
641 641 break
642 642
643 643 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
644 644
645 645 if showprofile:
646 646 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
647 647
648 648 counter += 1
649 649
650 650 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
651 651 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,timerange=None,
652 652 parameterIndex = None, onlyPositive = False,
653 653 SNRthresh = -numpy.inf, SNR = True, SNRmin = None, SNRmax = None,
654 654
655 655 zlabel = "", parameterName = "", parameterObject = "data_param",
656 656 save=False, figpath='', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
657 657 server=None, folder=None, username=None, password=None,
658 658 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
659 659
660 660 """
661 661
662 662 Input:
663 663 dataOut :
664 664 id :
665 665 wintitle :
666 666 channelList :
667 667 showProfile :
668 668 xmin : None,
669 669 xmax : None,
670 670 ymin : None,
671 671 ymax : None,
672 672 zmin : None,
673 673 zmax : None
674 674 """
675 675
676 676 data_param = getattr(dataOut, parameterObject)
677 677
678 678 if channelList == None:
679 679 channelIndexList = numpy.arange(data_param.shape[0])
680 680 else:
681 681 channelIndexList = numpy.array(channelList)
682 682
683 683 nchan = len(channelIndexList) #Number of channels being plotted
684 684
685 685 if timerange != None:
686 686 self.timerange = timerange
687 687
688 688 #tmin = None
689 689 #tmax = None
690 690 if parameterIndex == None:
691 691 parameterIndex = 1
692 692 x = dataOut.getTimeRange1()
693 693 y = dataOut.heightList
694 694 z = data_param[channelIndexList,parameterIndex,:].copy()
695 695
696 696 zRange = dataOut.abscissaList
697 697 nplots = z.shape[0] #Number of wind dimensions estimated
698 698 # thisDatetime = dataOut.datatime
699 699
700 700 if dataOut.data_SNR != None:
701 701 SNRarray = dataOut.data_SNR[channelIndexList,:]
702 702 SNRdB = 10*numpy.log10(SNRarray)
703 703 # SNRavgdB = 10*numpy.log10(SNRavg)
704 704 ind = numpy.where(SNRdB < 10**(SNRthresh/10))
705 705 z[ind] = numpy.nan
706 706
707 707 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
708 708 title = wintitle + " Parameters Plot" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
709 709 xlabel = ""
710 710 ylabel = "Range (Km)"
711 711
712 712 if SNR: nplots = 2*nplots
713 713
714 714 if onlyPositive:
715 715 colormap = "jet"
716 716 zmin = 0
717 717 else: colormap = "RdBu_r"
718 718
719 719 if not self.__isConfig:
720 720
721 721 self.setup(id=id,
722 722 nplots=nplots,
723 723 wintitle=wintitle,
724 724 showprofile=showprofile,
725 725 show=show)
726 726
727 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
727 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
728 728
729 729 if ymin == None: ymin = numpy.nanmin(y)
730 730 if ymax == None: ymax = numpy.nanmax(y)
731 731 if zmin == None: zmin = numpy.nanmin(zRange)
732 732 if zmax == None: zmax = numpy.nanmax(zRange)
733 733
734 734 if SNR != None:
735 735 if SNRmin == None: SNRmin = numpy.nanmin(SNRdB)
736 736 if SNRmax == None: SNRmax = numpy.nanmax(SNRdB)
737 737
738 738 self.FTP_WEI = ftp_wei
739 739 self.EXP_CODE = exp_code
740 740 self.SUB_EXP_CODE = sub_exp_code
741 741 self.PLOT_POS = plot_pos
742 742
743 743 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
744 744 self.__isConfig = True
745 745 self.figfile = figfile
746 746
747 747 self.setWinTitle(title)
748 748
749 749 if ((self.xmax - x[1]) < (x[1]-x[0])):
750 750 x[1] = self.xmax
751 751
752 752 for i in range(nchan):
753 753 if SNR: j = 2*i
754 754 else: j = i
755 755
756 756 title = "%s Channel %d: %s" %(parameterName, channelIndexList[i]+1, thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
757 757
758 758 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
759 759 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
760 760 axes = self.axesList[j*self.__nsubplots]
761 761 z1 = z[i,:].reshape((1,-1))
762 762 axes.pcolorbuffer(x, y, z1,
763 763 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
764 764 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap=colormap,
765 765 ticksize=9, cblabel=zlabel, cbsize="1%")
766 766
767 767 if SNR:
768 768 title = "Channel %d Signal Noise Ratio (SNR): %s" %(channelIndexList[i]+1, thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
769 769 axes = self.axesList[(j + 1)*self.__nsubplots]
770 770 z1 = SNRdB[i,:].reshape((1,-1))
771 771 axes.pcolorbuffer(x, y, z1,
772 772 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
773 773 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap="jet",
774 774 ticksize=9, cblabel=zlabel, cbsize="1%")
775 775
776 776
777 777
778 778 self.draw()
779 779
780 780 if self.figfile == None:
781 781 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
782 782 self.figfile = self.getFilename(name = str_datetime)
783 783
784 784 if figpath != '':
785 785
786 786 self.counter_imagwr += 1
787 787 if (self.counter_imagwr>=wr_period):
788 788 # store png plot to local folder
789 789 self.saveFigure(figpath, self.figfile)
790 790 # store png plot to FTP server according to RT-Web format
791 791 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
792 792 ftp_filename = os.path.join(figpath, name)
793 793 self.saveFigure(figpath, ftp_filename)
794 794
795 795 self.counter_imagwr = 0
796 796
797 797 if x[1] >= self.axesList[0].xmax:
798 798 self.counter_imagwr = wr_period
799 799 self.__isConfig = False
800 800 self.figfile = None
801 801
802 802
803 803 class SpectralFittingPlot(Figure):
804 804
805 805 __isConfig = None
806 806 __nsubplots = None
807 807
808 808 WIDTHPROF = None
809 809 HEIGHTPROF = None
810 810 PREFIX = 'prm'
811 811
812 812
813 813 N = None
814 814 ippSeconds = None
815 815
816 816 def __init__(self):
817 817 self.__isConfig = False
818 818 self.__nsubplots = 1
819 819
820 820 self.WIDTH = 450
821 821 self.HEIGHT = 250
822 822 self.WIDTHPROF = 0
823 823 self.HEIGHTPROF = 0
824 824
825 825 def getSubplots(self):
826 826
827 827 ncol = int(numpy.sqrt(self.nplots)+0.9)
828 828 nrow = int(self.nplots*1./ncol + 0.9)
829 829
830 830 return nrow, ncol
831 831
832 832 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
833 833
834 834 showprofile = False
835 835 self.__showprofile = showprofile
836 836 self.nplots = nplots
837 837
838 838 ncolspan = 5
839 839 colspan = 4
840 840 if showprofile:
841 841 ncolspan = 5
842 842 colspan = 4
843 843 self.__nsubplots = 2
844 844
845 845 self.createFigure(id = id,
846 846 wintitle = wintitle,
847 847 widthplot = self.WIDTH + self.WIDTHPROF,
848 848 heightplot = self.HEIGHT + self.HEIGHTPROF,
849 849 show=show)
850 850
851 851 nrow, ncol = self.getSubplots()
852 852
853 853 counter = 0
854 854 for y in range(nrow):
855 855 for x in range(ncol):
856 856
857 857 if counter >= self.nplots:
858 858 break
859 859
860 860 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
861 861
862 862 if showprofile:
863 863 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
864 864
865 865 counter += 1
866 866
867 867 def run(self, dataOut, id, cutHeight=None, fit=False, wintitle="", channelList=None, showprofile=True,
868 868 xmin=None, xmax=None, ymin=None, ymax=None,
869 869 save=False, figpath='./', figfile=None, show=True):
870 870
871 871 """
872 872
873 873 Input:
874 874 dataOut :
875 875 id :
876 876 wintitle :
877 877 channelList :
878 878 showProfile :
879 879 xmin : None,
880 880 xmax : None,
881 881 zmin : None,
882 882 zmax : None
883 883 """
884 884
885 885 if cutHeight==None:
886 886 h=270
887 887 heightindex = numpy.abs(cutHeight - dataOut.heightList).argmin()
888 888 cutHeight = dataOut.heightList[heightindex]
889 889
890 890 factor = dataOut.normFactor
891 891 x = dataOut.abscissaList[:-1]
892 892 #y = dataOut.getHeiRange()
893 893
894 894 z = dataOut.data_pre[:,:,heightindex]/factor
895 895 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
896 896 avg = numpy.average(z, axis=1)
897 897 listChannels = z.shape[0]
898 898
899 899 #Reconstruct Function
900 900 if fit==True:
901 901 groupArray = dataOut.groupList
902 902 listChannels = groupArray.reshape((groupArray.size))
903 903 listChannels.sort()
904 904 spcFitLine = numpy.zeros(z.shape)
905 905 constants = dataOut.constants
906 906
907 907 nGroups = groupArray.shape[0]
908 908 nChannels = groupArray.shape[1]
909 909 nProfiles = z.shape[1]
910 910
911 911 for f in range(nGroups):
912 912 groupChann = groupArray[f,:]
913 913 p = dataOut.data_param[f,:,heightindex]
914 914 # p = numpy.array([ 89.343967,0.14036615,0.17086219,18.89835291,1.58388365,1.55099167])
915 915 fitLineAux = dataOut.library.modelFunction(p, constants)*nProfiles
916 916 fitLineAux = fitLineAux.reshape((nChannels,nProfiles))
917 917 spcFitLine[groupChann,:] = fitLineAux
918 918 # spcFitLine = spcFitLine/factor
919 919
920 920 z = z[listChannels,:]
921 921 spcFitLine = spcFitLine[listChannels,:]
922 922 spcFitLinedB = 10*numpy.log10(spcFitLine)
923 923
924 924 zdB = 10*numpy.log10(z)
925 925 #thisDatetime = dataOut.datatime
926 926 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
927 927 title = wintitle + " Doppler Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
928 928 xlabel = "Velocity (m/s)"
929 929 ylabel = "Spectrum"
930 930
931 931 if not self.__isConfig:
932 932
933 933 nplots = listChannels.size
934 934
935 935 self.setup(id=id,
936 936 nplots=nplots,
937 937 wintitle=wintitle,
938 938 showprofile=showprofile,
939 939 show=show)
940 940
941 941 if xmin == None: xmin = numpy.nanmin(x)
942 942 if xmax == None: xmax = numpy.nanmax(x)
943 943 if ymin == None: ymin = numpy.nanmin(zdB)
944 944 if ymax == None: ymax = numpy.nanmax(zdB)+2
945 945
946 946 self.__isConfig = True
947 947
948 948 self.setWinTitle(title)
949 949 for i in range(self.nplots):
950 950 # title = "Channel %d: %4.2fdB" %(dataOut.channelList[i]+1, noisedB[i])
951 951 title = "Height %4.1f km\nChannel %d:" %(cutHeight, listChannels[i]+1)
952 952 axes = self.axesList[i*self.__nsubplots]
953 953 if fit == False:
954 954 axes.pline(x, zdB[i,:],
955 955 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
956 956 xlabel=xlabel, ylabel=ylabel, title=title
957 957 )
958 958 if fit == True:
959 959 fitline=spcFitLinedB[i,:]
960 960 y=numpy.vstack([zdB[i,:],fitline] )
961 961 legendlabels=['Data','Fitting']
962 962 axes.pmultilineyaxis(x, y,
963 963 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
964 964 xlabel=xlabel, ylabel=ylabel, title=title,
965 965 legendlabels=legendlabels, marker=None,
966 966 linestyle='solid', grid='both')
967 967
968 968 self.draw()
969 969
970 970 if save:
971 971 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
972 972 if figfile == None:
973 973 figfile = self.getFilename(name = date)
974 974
975 975 self.saveFigure(figpath, figfile)
976 976
977 977
978 978 class EWDriftsPlot(Figure):
979 979
980 980 __isConfig = None
981 981 __nsubplots = None
982 982
983 983 WIDTHPROF = None
984 984 HEIGHTPROF = None
985 985 PREFIX = 'drift'
986 986
987 987 def __init__(self):
988 988
989 989 self.timerange = 2*60*60
990 990 self.isConfig = False
991 991 self.__nsubplots = 1
992 992
993 993 self.WIDTH = 800
994 994 self.HEIGHT = 150
995 995 self.WIDTHPROF = 120
996 996 self.HEIGHTPROF = 0
997 997 self.counter_imagwr = 0
998 998
999 999 self.PLOT_CODE = 0
1000 1000 self.FTP_WEI = None
1001 1001 self.EXP_CODE = None
1002 1002 self.SUB_EXP_CODE = None
1003 1003 self.PLOT_POS = None
1004 1004 self.tmin = None
1005 1005 self.tmax = None
1006 1006
1007 1007 self.xmin = None
1008 1008 self.xmax = None
1009 1009
1010 1010 self.figfile = None
1011 1011
1012 1012 def getSubplots(self):
1013 1013
1014 1014 ncol = 1
1015 1015 nrow = self.nplots
1016 1016
1017 1017 return nrow, ncol
1018 1018
1019 1019 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1020 1020
1021 1021 self.__showprofile = showprofile
1022 1022 self.nplots = nplots
1023 1023
1024 1024 ncolspan = 1
1025 1025 colspan = 1
1026 1026
1027 1027 self.createFigure(id = id,
1028 1028 wintitle = wintitle,
1029 1029 widthplot = self.WIDTH + self.WIDTHPROF,
1030 1030 heightplot = self.HEIGHT + self.HEIGHTPROF,
1031 1031 show=show)
1032 1032
1033 1033 nrow, ncol = self.getSubplots()
1034 1034
1035 1035 counter = 0
1036 1036 for y in range(nrow):
1037 1037 if counter >= self.nplots:
1038 1038 break
1039 1039
1040 1040 self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
1041 1041 counter += 1
1042 1042
1043 1043 def run(self, dataOut, id, wintitle="", channelList=None,
1044 1044 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
1045 1045 zmaxVertical = None, zminVertical = None, zmaxZonal = None, zminZonal = None,
1046 1046 timerange=None, SNRthresh = -numpy.inf, SNRmin = None, SNRmax = None, SNR_1 = False,
1047 1047 save=False, figpath='', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
1048 1048 server=None, folder=None, username=None, password=None,
1049 1049 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1050 1050 """
1051 1051
1052 1052 Input:
1053 1053 dataOut :
1054 1054 id :
1055 1055 wintitle :
1056 1056 channelList :
1057 1057 showProfile :
1058 1058 xmin : None,
1059 1059 xmax : None,
1060 1060 ymin : None,
1061 1061 ymax : None,
1062 1062 zmin : None,
1063 1063 zmax : None
1064 1064 """
1065 1065
1066 1066 if timerange != None:
1067 1067 self.timerange = timerange
1068 1068
1069 1069 tmin = None
1070 1070 tmax = None
1071 1071
1072 1072 x = dataOut.getTimeRange1()
1073 1073 # y = dataOut.heightList
1074 1074 y = dataOut.heightList
1075 1075
1076 1076 z = dataOut.data_output
1077 1077 nplots = z.shape[0] #Number of wind dimensions estimated
1078 1078 nplotsw = nplots
1079 1079
1080 1080 #If there is a SNR function defined
1081 1081 if dataOut.data_SNR != None:
1082 1082 nplots += 1
1083 1083 SNR = dataOut.data_SNR
1084 1084
1085 1085 if SNR_1:
1086 1086 SNR += 1
1087 1087
1088 1088 SNRavg = numpy.average(SNR, axis=0)
1089 1089
1090 1090 SNRdB = 10*numpy.log10(SNR)
1091 1091 SNRavgdB = 10*numpy.log10(SNRavg)
1092 1092
1093 1093 ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
1094 1094
1095 1095 for i in range(nplotsw):
1096 1096 z[i,ind] = numpy.nan
1097 1097
1098 1098
1099 1099 showprofile = False
1100 1100 # thisDatetime = dataOut.datatime
1101 1101 thisDatetime = datetime.datetime.utcfromtimestamp(x[1])
1102 1102 title = wintitle + " EW Drifts"
1103 1103 xlabel = ""
1104 1104 ylabel = "Height (Km)"
1105 1105
1106 1106 if not self.__isConfig:
1107 1107
1108 1108 self.setup(id=id,
1109 1109 nplots=nplots,
1110 1110 wintitle=wintitle,
1111 1111 showprofile=showprofile,
1112 1112 show=show)
1113 1113
1114 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
1114 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
1115 1115
1116 1116 if ymin == None: ymin = numpy.nanmin(y)
1117 1117 if ymax == None: ymax = numpy.nanmax(y)
1118 1118
1119 1119 if zmaxZonal == None: zmaxZonal = numpy.nanmax(abs(z[0,:]))
1120 1120 if zminZonal == None: zminZonal = -zmaxZonal
1121 1121 if zmaxVertical == None: zmaxVertical = numpy.nanmax(abs(z[1,:]))
1122 1122 if zminVertical == None: zminVertical = -zmaxVertical
1123 1123
1124 1124 if dataOut.data_SNR != None:
1125 1125 if SNRmin == None: SNRmin = numpy.nanmin(SNRavgdB)
1126 1126 if SNRmax == None: SNRmax = numpy.nanmax(SNRavgdB)
1127 1127
1128 1128 self.FTP_WEI = ftp_wei
1129 1129 self.EXP_CODE = exp_code
1130 1130 self.SUB_EXP_CODE = sub_exp_code
1131 1131 self.PLOT_POS = plot_pos
1132 1132
1133 1133 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1134 1134 self.__isConfig = True
1135 1135
1136 1136
1137 1137 self.setWinTitle(title)
1138 1138
1139 1139 if ((self.xmax - x[1]) < (x[1]-x[0])):
1140 1140 x[1] = self.xmax
1141 1141
1142 1142 strWind = ['Zonal','Vertical']
1143 1143 strCb = 'Velocity (m/s)'
1144 1144 zmaxVector = [zmaxZonal, zmaxVertical]
1145 1145 zminVector = [zminZonal, zminVertical]
1146 1146
1147 1147 for i in range(nplotsw):
1148 1148
1149 1149 title = "%s Drifts: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1150 1150 axes = self.axesList[i*self.__nsubplots]
1151 1151
1152 1152 z1 = z[i,:].reshape((1,-1))
1153 1153
1154 1154 axes.pcolorbuffer(x, y, z1,
1155 1155 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
1156 1156 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
1157 1157 ticksize=9, cblabel=strCb, cbsize="1%", colormap="RdBu_r")
1158 1158
1159 1159 if dataOut.data_SNR != None:
1160 1160 i += 1
1161 1161 if SNR_1:
1162 1162 title = "Signal Noise Ratio + 1 (SNR+1): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1163 1163 else:
1164 1164 title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1165 1165 axes = self.axesList[i*self.__nsubplots]
1166 1166 SNRavgdB = SNRavgdB.reshape((1,-1))
1167 1167
1168 1168 axes.pcolorbuffer(x, y, SNRavgdB,
1169 1169 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
1170 1170 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
1171 1171 ticksize=9, cblabel='', cbsize="1%", colormap="jet")
1172 1172
1173 1173 self.draw()
1174 1174
1175 1175 if self.figfile == None:
1176 1176 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
1177 1177 self.figfile = self.getFilename(name = str_datetime)
1178 1178
1179 1179 if figpath != '':
1180 1180
1181 1181 self.counter_imagwr += 1
1182 1182 if (self.counter_imagwr>=wr_period):
1183 1183 # store png plot to local folder
1184 1184 self.saveFigure(figpath, self.figfile)
1185 1185 # store png plot to FTP server according to RT-Web format
1186 1186 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
1187 1187 ftp_filename = os.path.join(figpath, name)
1188 1188 self.saveFigure(figpath, ftp_filename)
1189 1189
1190 1190 self.counter_imagwr = 0
1191 1191
1192 1192 if x[1] >= self.axesList[0].xmax:
1193 1193 self.counter_imagwr = wr_period
1194 1194 self.__isConfig = False
1195 1195 self.figfile = None No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1356 +1,1356
1 1 '''
2 2 @author: Daniel Suarez
3 3 '''
4 4 import os
5 5 import datetime
6 6 import numpy
7 7
8 8 from figure import Figure, isRealtime
9 9
10 10 class SpectraPlot(Figure):
11 11
12 12 isConfig = None
13 13 __nsubplots = None
14 14
15 15 WIDTHPROF = None
16 16 HEIGHTPROF = None
17 17 PREFIX = 'spc'
18 18
19 19 def __init__(self):
20 20
21 21 self.isConfig = False
22 22 self.__nsubplots = 1
23 23
24 24 self.WIDTH = 280
25 25 self.HEIGHT = 250
26 26 self.WIDTHPROF = 120
27 27 self.HEIGHTPROF = 0
28 28 self.counter_imagwr = 0
29 29
30 30 self.PLOT_CODE = 1
31 31 self.FTP_WEI = None
32 32 self.EXP_CODE = None
33 33 self.SUB_EXP_CODE = None
34 34 self.PLOT_POS = None
35 35
36 36 def getSubplots(self):
37 37
38 38 ncol = int(numpy.sqrt(self.nplots)+0.9)
39 39 nrow = int(self.nplots*1./ncol + 0.9)
40 40
41 41 return nrow, ncol
42 42
43 43 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
44 44
45 45 self.__showprofile = showprofile
46 46 self.nplots = nplots
47 47
48 48 ncolspan = 1
49 49 colspan = 1
50 50 if showprofile:
51 51 ncolspan = 3
52 52 colspan = 2
53 53 self.__nsubplots = 2
54 54
55 55 self.createFigure(id = id,
56 56 wintitle = wintitle,
57 57 widthplot = self.WIDTH + self.WIDTHPROF,
58 58 heightplot = self.HEIGHT + self.HEIGHTPROF,
59 59 show=show)
60 60
61 61 nrow, ncol = self.getSubplots()
62 62
63 63 counter = 0
64 64 for y in range(nrow):
65 65 for x in range(ncol):
66 66
67 67 if counter >= self.nplots:
68 68 break
69 69
70 70 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
71 71
72 72 if showprofile:
73 73 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
74 74
75 75 counter += 1
76 76
77 77 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
78 78 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
79 79 save=False, figpath='', figfile=None, show=True, ftp=False, wr_period=1,
80 80 server=None, folder=None, username=None, password=None,
81 81 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
82 82
83 83 """
84 84
85 85 Input:
86 86 dataOut :
87 87 id :
88 88 wintitle :
89 89 channelList :
90 90 showProfile :
91 91 xmin : None,
92 92 xmax : None,
93 93 ymin : None,
94 94 ymax : None,
95 95 zmin : None,
96 96 zmax : None
97 97 """
98 98
99 99 if dataOut.flagNoData:
100 100 return None
101 101
102 102 if realtime:
103 103 if not(isRealtime(utcdatatime = dataOut.utctime)):
104 104 print 'Skipping this plot function'
105 105 return
106 106
107 107 if channelList == None:
108 108 channelIndexList = dataOut.channelIndexList
109 109 else:
110 110 channelIndexList = []
111 111 for channel in channelList:
112 112 if channel not in dataOut.channelList:
113 113 raise ValueError, "Channel %d is not in dataOut.channelList"
114 114 channelIndexList.append(dataOut.channelList.index(channel))
115 115
116 116 factor = dataOut.normFactor
117 117
118 118 x = dataOut.getVelRange(1)
119 119 y = dataOut.getHeiRange()
120 120
121 121 z = dataOut.data_spc[channelIndexList,:,:]/factor
122 122 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
123 123 avg = numpy.average(z, axis=1)
124 124 #avg = numpy.nanmean(z, axis=1)
125 125 noise = dataOut.noise/factor
126 126
127 127 zdB = 10*numpy.log10(z)
128 128 avgdB = 10*numpy.log10(avg)
129 129 noisedB = 10*numpy.log10(noise)
130 130
131 131 #thisDatetime = dataOut.datatime
132 132 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
133 133 title = wintitle + " Spectra"
134 134 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
135 135 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
136 136
137 137 xlabel = "Velocity (m/s)"
138 138 ylabel = "Range (Km)"
139 139
140 140 if not self.isConfig:
141 141
142 142 nplots = len(channelIndexList)
143 143
144 144 self.setup(id=id,
145 145 nplots=nplots,
146 146 wintitle=wintitle,
147 147 showprofile=showprofile,
148 148 show=show)
149 149
150 150 if xmin == None: xmin = numpy.nanmin(x)
151 151 if xmax == None: xmax = numpy.nanmax(x)
152 152 if ymin == None: ymin = numpy.nanmin(y)
153 153 if ymax == None: ymax = numpy.nanmax(y)
154 154 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
155 155 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
156 156
157 157 self.FTP_WEI = ftp_wei
158 158 self.EXP_CODE = exp_code
159 159 self.SUB_EXP_CODE = sub_exp_code
160 160 self.PLOT_POS = plot_pos
161 161
162 162 self.isConfig = True
163 163
164 164 self.setWinTitle(title)
165 165
166 166 for i in range(self.nplots):
167 167 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
168 168 title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i]+1, noisedB[i], str_datetime)
169 169 if len(dataOut.beam.codeList) != 0:
170 170 title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[i]+1, noisedB[i], dataOut.beam.azimuthList[i], dataOut.beam.zenithList[i], str_datetime)
171 171
172 172 axes = self.axesList[i*self.__nsubplots]
173 173 axes.pcolor(x, y, zdB[i,:,:],
174 174 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
175 175 xlabel=xlabel, ylabel=ylabel, title=title,
176 176 ticksize=9, cblabel='')
177 177
178 178 if self.__showprofile:
179 179 axes = self.axesList[i*self.__nsubplots +1]
180 180 axes.pline(avgdB[i], y,
181 181 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
182 182 xlabel='dB', ylabel='', title='',
183 183 ytick_visible=False,
184 184 grid='x')
185 185
186 186 noiseline = numpy.repeat(noisedB[i], len(y))
187 187 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
188 188
189 189 self.draw()
190 190
191 191 if figfile == None:
192 192 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
193 193 figfile = self.getFilename(name = str_datetime)
194 194 name = str_datetime
195 195 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
196 196 name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
197 197 figfile = self.getFilename(name)
198 198 if figpath != '':
199 199 self.counter_imagwr += 1
200 200 if (self.counter_imagwr>=wr_period):
201 201 # store png plot to local folder
202 202 self.saveFigure(figpath, figfile)
203 203 # store png plot to FTP server according to RT-Web format
204 204 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
205 205 ftp_filename = os.path.join(figpath, name)
206 206 self.saveFigure(figpath, ftp_filename)
207 207 self.counter_imagwr = 0
208 208
209 209
210 210 class CrossSpectraPlot(Figure):
211 211
212 212 isConfig = None
213 213 __nsubplots = None
214 214
215 215 WIDTH = None
216 216 HEIGHT = None
217 217 WIDTHPROF = None
218 218 HEIGHTPROF = None
219 219 PREFIX = 'cspc'
220 220
221 221 def __init__(self):
222 222
223 223 self.isConfig = False
224 224 self.__nsubplots = 4
225 225 self.counter_imagwr = 0
226 226 self.WIDTH = 250
227 227 self.HEIGHT = 250
228 228 self.WIDTHPROF = 0
229 229 self.HEIGHTPROF = 0
230 230
231 231 self.PLOT_CODE = 1
232 232 self.FTP_WEI = None
233 233 self.EXP_CODE = None
234 234 self.SUB_EXP_CODE = None
235 235 self.PLOT_POS = None
236 236
237 237 def getSubplots(self):
238 238
239 239 ncol = 4
240 240 nrow = self.nplots
241 241
242 242 return nrow, ncol
243 243
244 244 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
245 245
246 246 self.__showprofile = showprofile
247 247 self.nplots = nplots
248 248
249 249 ncolspan = 1
250 250 colspan = 1
251 251
252 252 self.createFigure(id = id,
253 253 wintitle = wintitle,
254 254 widthplot = self.WIDTH + self.WIDTHPROF,
255 255 heightplot = self.HEIGHT + self.HEIGHTPROF,
256 256 show=True)
257 257
258 258 nrow, ncol = self.getSubplots()
259 259
260 260 counter = 0
261 261 for y in range(nrow):
262 262 for x in range(ncol):
263 263 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
264 264
265 265 counter += 1
266 266
267 267 def run(self, dataOut, id, wintitle="", pairsList=None,
268 268 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
269 269 save=False, figpath='', figfile=None, ftp=False, wr_period=1,
270 270 power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
271 271 server=None, folder=None, username=None, password=None,
272 272 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
273 273
274 274 """
275 275
276 276 Input:
277 277 dataOut :
278 278 id :
279 279 wintitle :
280 280 channelList :
281 281 showProfile :
282 282 xmin : None,
283 283 xmax : None,
284 284 ymin : None,
285 285 ymax : None,
286 286 zmin : None,
287 287 zmax : None
288 288 """
289 289
290 290 if pairsList == None:
291 291 pairsIndexList = dataOut.pairsIndexList
292 292 else:
293 293 pairsIndexList = []
294 294 for pair in pairsList:
295 295 if pair not in dataOut.pairsList:
296 296 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
297 297 pairsIndexList.append(dataOut.pairsList.index(pair))
298 298
299 299 if pairsIndexList == []:
300 300 return
301 301
302 302 if len(pairsIndexList) > 4:
303 303 pairsIndexList = pairsIndexList[0:4]
304 304 factor = dataOut.normFactor
305 305 x = dataOut.getVelRange(1)
306 306 y = dataOut.getHeiRange()
307 307 z = dataOut.data_spc[:,:,:]/factor
308 308 # z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
309 309 avg = numpy.abs(numpy.average(z, axis=1))
310 310 noise = dataOut.noise/factor
311 311
312 312 zdB = 10*numpy.log10(z)
313 313 avgdB = 10*numpy.log10(avg)
314 314 noisedB = 10*numpy.log10(noise)
315 315
316 316
317 317 #thisDatetime = dataOut.datatime
318 318 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
319 319 title = wintitle + " Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
320 320 xlabel = "Velocity (m/s)"
321 321 ylabel = "Range (Km)"
322 322
323 323 if not self.isConfig:
324 324
325 325 nplots = len(pairsIndexList)
326 326
327 327 self.setup(id=id,
328 328 nplots=nplots,
329 329 wintitle=wintitle,
330 330 showprofile=False,
331 331 show=show)
332 332
333 333 if xmin == None: xmin = numpy.nanmin(x)
334 334 if xmax == None: xmax = numpy.nanmax(x)
335 335 if ymin == None: ymin = numpy.nanmin(y)
336 336 if ymax == None: ymax = numpy.nanmax(y)
337 337 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
338 338 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
339 339
340 340 self.FTP_WEI = ftp_wei
341 341 self.EXP_CODE = exp_code
342 342 self.SUB_EXP_CODE = sub_exp_code
343 343 self.PLOT_POS = plot_pos
344 344
345 345 self.isConfig = True
346 346
347 347 self.setWinTitle(title)
348 348
349 349 for i in range(self.nplots):
350 350 pair = dataOut.pairsList[pairsIndexList[i]]
351 351 str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
352 352 title = "Ch%d: %4.2fdB: %s" %(pair[0], noisedB[pair[0]], str_datetime)
353 353 zdB = 10.*numpy.log10(dataOut.data_spc[pair[0],:,:]/factor)
354 354 axes0 = self.axesList[i*self.__nsubplots]
355 355 axes0.pcolor(x, y, zdB,
356 356 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
357 357 xlabel=xlabel, ylabel=ylabel, title=title,
358 358 ticksize=9, colormap=power_cmap, cblabel='')
359 359
360 360 title = "Ch%d: %4.2fdB: %s" %(pair[1], noisedB[pair[1]], str_datetime)
361 361 zdB = 10.*numpy.log10(dataOut.data_spc[pair[1],:,:]/factor)
362 362 axes0 = self.axesList[i*self.__nsubplots+1]
363 363 axes0.pcolor(x, y, zdB,
364 364 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
365 365 xlabel=xlabel, ylabel=ylabel, title=title,
366 366 ticksize=9, colormap=power_cmap, cblabel='')
367 367
368 368 coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
369 369 coherence = numpy.abs(coherenceComplex)
370 370 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
371 371 phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
372 372
373 373 title = "Coherence %d%d" %(pair[0], pair[1])
374 374 axes0 = self.axesList[i*self.__nsubplots+2]
375 375 axes0.pcolor(x, y, coherence,
376 376 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
377 377 xlabel=xlabel, ylabel=ylabel, title=title,
378 378 ticksize=9, colormap=coherence_cmap, cblabel='')
379 379
380 380 title = "Phase %d%d" %(pair[0], pair[1])
381 381 axes0 = self.axesList[i*self.__nsubplots+3]
382 382 axes0.pcolor(x, y, phase,
383 383 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
384 384 xlabel=xlabel, ylabel=ylabel, title=title,
385 385 ticksize=9, colormap=phase_cmap, cblabel='')
386 386
387 387
388 388
389 389 self.draw()
390 390
391 391 if figfile == None:
392 392 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
393 393 figfile = self.getFilename(name = str_datetime)
394 394
395 395 if figpath != '':
396 396 self.counter_imagwr += 1
397 397 if (self.counter_imagwr>=wr_period):
398 398 # store png plot to local folder
399 399 self.saveFigure(figpath, figfile)
400 400 # store png plot to FTP server according to RT-Web format
401 401 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
402 402 ftp_filename = os.path.join(figpath, name)
403 403 self.saveFigure(figpath, ftp_filename)
404 404 self.counter_imagwr = 0
405 405
406 406
407 407 class RTIPlot(Figure):
408 408
409 409 __isConfig = None
410 410 __nsubplots = None
411 411
412 412 WIDTHPROF = None
413 413 HEIGHTPROF = None
414 414 PREFIX = 'rti'
415 415
416 416 def __init__(self):
417 417
418 418 self.timerange = 2*60*60
419 419 self.__isConfig = False
420 420 self.__nsubplots = 1
421 421
422 422 self.WIDTH = 800
423 423 self.HEIGHT = 150
424 424 self.WIDTHPROF = 120
425 425 self.HEIGHTPROF = 0
426 426 self.counter_imagwr = 0
427 427
428 428 self.PLOT_CODE = 0
429 429 self.FTP_WEI = None
430 430 self.EXP_CODE = None
431 431 self.SUB_EXP_CODE = None
432 432 self.PLOT_POS = None
433 433 self.tmin = None
434 434 self.tmax = None
435 435
436 436 self.xmin = None
437 437 self.xmax = None
438 438
439 439 self.figfile = None
440 440
441 441 def getSubplots(self):
442 442
443 443 ncol = 1
444 444 nrow = self.nplots
445 445
446 446 return nrow, ncol
447 447
448 448 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
449 449
450 450 self.__showprofile = showprofile
451 451 self.nplots = nplots
452 452
453 453 ncolspan = 1
454 454 colspan = 1
455 455 if showprofile:
456 456 ncolspan = 7
457 457 colspan = 6
458 458 self.__nsubplots = 2
459 459
460 460 self.createFigure(id = id,
461 461 wintitle = wintitle,
462 462 widthplot = self.WIDTH + self.WIDTHPROF,
463 463 heightplot = self.HEIGHT + self.HEIGHTPROF,
464 464 show=show)
465 465
466 466 nrow, ncol = self.getSubplots()
467 467
468 468 counter = 0
469 469 for y in range(nrow):
470 470 for x in range(ncol):
471 471
472 472 if counter >= self.nplots:
473 473 break
474 474
475 475 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
476 476
477 477 if showprofile:
478 478 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
479 479
480 480 counter += 1
481 481
482 482 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
483 483 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
484 484 timerange=None,
485 485 save=False, figpath='', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
486 486 server=None, folder=None, username=None, password=None,
487 487 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
488 488
489 489 """
490 490
491 491 Input:
492 492 dataOut :
493 493 id :
494 494 wintitle :
495 495 channelList :
496 496 showProfile :
497 497 xmin : None,
498 498 xmax : None,
499 499 ymin : None,
500 500 ymax : None,
501 501 zmin : None,
502 502 zmax : None
503 503 """
504 504
505 505 if channelList == None:
506 506 channelIndexList = dataOut.channelIndexList
507 507 else:
508 508 channelIndexList = []
509 509 for channel in channelList:
510 510 if channel not in dataOut.channelList:
511 511 raise ValueError, "Channel %d is not in dataOut.channelList"
512 512 channelIndexList.append(dataOut.channelList.index(channel))
513 513
514 514 if timerange != None:
515 515 self.timerange = timerange
516 516
517 517 #tmin = None
518 518 #tmax = None
519 519 factor = dataOut.normFactor
520 520 x = dataOut.getTimeRange()
521 521 y = dataOut.getHeiRange()
522 522
523 523 z = dataOut.data_spc[channelIndexList,:,:]/factor
524 524 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
525 525 avg = numpy.average(z, axis=1)
526 526
527 527 avgdB = 10.*numpy.log10(avg)
528 528
529 529
530 530 # thisDatetime = dataOut.datatime
531 531 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
532 532 title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
533 533 xlabel = ""
534 534 ylabel = "Range (Km)"
535 535
536 536 if not self.__isConfig:
537 537
538 538 nplots = len(channelIndexList)
539 539
540 540 self.setup(id=id,
541 541 nplots=nplots,
542 542 wintitle=wintitle,
543 543 showprofile=showprofile,
544 544 show=show)
545 545
546 546 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
547 547
548 548 # if timerange != None:
549 549 # self.timerange = timerange
550 # self.xmin, self.tmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
550 # self.xmin, self.tmax = self.getTimeLim(x, xmin, xmax, timerange)
551 551
552 552
553 553
554 554 if ymin == None: ymin = numpy.nanmin(y)
555 555 if ymax == None: ymax = numpy.nanmax(y)
556 556 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
557 557 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
558 558
559 559 self.FTP_WEI = ftp_wei
560 560 self.EXP_CODE = exp_code
561 561 self.SUB_EXP_CODE = sub_exp_code
562 562 self.PLOT_POS = plot_pos
563 563
564 564 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
565 565 self.__isConfig = True
566 566 self.figfile = figfile
567 567
568 568 self.setWinTitle(title)
569 569
570 570 if ((self.xmax - x[1]) < (x[1]-x[0])):
571 571 x[1] = self.xmax
572 572
573 573 for i in range(self.nplots):
574 574 title = "Channel %d: %s" %(dataOut.channelList[i]+1, thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
575 575 if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
576 576 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
577 577 axes = self.axesList[i*self.__nsubplots]
578 578 zdB = avgdB[i].reshape((1,-1))
579 579 axes.pcolorbuffer(x, y, zdB,
580 580 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
581 581 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
582 582 ticksize=9, cblabel='', cbsize="1%")
583 583
584 584 if self.__showprofile:
585 585 axes = self.axesList[i*self.__nsubplots +1]
586 586 axes.pline(avgdB[i], y,
587 587 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
588 588 xlabel='dB', ylabel='', title='',
589 589 ytick_visible=False,
590 590 grid='x')
591 591
592 592 self.draw()
593 593
594 594 if self.figfile == None:
595 595 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
596 596 self.figfile = self.getFilename(name = str_datetime)
597 597
598 598 if figpath != '':
599 599
600 600 self.counter_imagwr += 1
601 601 if (self.counter_imagwr>=wr_period):
602 602 # store png plot to local folder
603 603 self.saveFigure(figpath, self.figfile)
604 604 # store png plot to FTP server according to RT-Web format
605 605 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
606 606 ftp_filename = os.path.join(figpath, name)
607 607 self.saveFigure(figpath, ftp_filename)
608 608
609 609 self.counter_imagwr = 0
610 610
611 611 if x[1] >= self.axesList[0].xmax:
612 612 self.counter_imagwr = wr_period
613 613 self.__isConfig = False
614 614 self.figfile = None
615 615
616 616 class CoherenceMap(Figure):
617 617 isConfig = None
618 618 __nsubplots = None
619 619
620 620 WIDTHPROF = None
621 621 HEIGHTPROF = None
622 622 PREFIX = 'cmap'
623 623
624 624 def __init__(self):
625 625 self.timerange = 2*60*60
626 626 self.isConfig = False
627 627 self.__nsubplots = 1
628 628
629 629 self.WIDTH = 800
630 630 self.HEIGHT = 150
631 631 self.WIDTHPROF = 120
632 632 self.HEIGHTPROF = 0
633 633 self.counter_imagwr = 0
634 634
635 635 self.PLOT_CODE = 3
636 636 self.FTP_WEI = None
637 637 self.EXP_CODE = None
638 638 self.SUB_EXP_CODE = None
639 639 self.PLOT_POS = None
640 640 self.counter_imagwr = 0
641 641
642 642 self.xmin = None
643 643 self.xmax = None
644 644
645 645 def getSubplots(self):
646 646 ncol = 1
647 647 nrow = self.nplots*2
648 648
649 649 return nrow, ncol
650 650
651 651 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
652 652 self.__showprofile = showprofile
653 653 self.nplots = nplots
654 654
655 655 ncolspan = 1
656 656 colspan = 1
657 657 if showprofile:
658 658 ncolspan = 7
659 659 colspan = 6
660 660 self.__nsubplots = 2
661 661
662 662 self.createFigure(id = id,
663 663 wintitle = wintitle,
664 664 widthplot = self.WIDTH + self.WIDTHPROF,
665 665 heightplot = self.HEIGHT + self.HEIGHTPROF,
666 666 show=True)
667 667
668 668 nrow, ncol = self.getSubplots()
669 669
670 670 for y in range(nrow):
671 671 for x in range(ncol):
672 672
673 673 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
674 674
675 675 if showprofile:
676 676 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
677 677
678 678 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
679 679 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
680 680 timerange=None,
681 681 save=False, figpath='', figfile=None, ftp=False, wr_period=1,
682 682 coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
683 683 server=None, folder=None, username=None, password=None,
684 684 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
685 685
686 686 if pairsList == None:
687 687 pairsIndexList = dataOut.pairsIndexList
688 688 else:
689 689 pairsIndexList = []
690 690 for pair in pairsList:
691 691 if pair not in dataOut.pairsList:
692 692 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
693 693 pairsIndexList.append(dataOut.pairsList.index(pair))
694 694
695 695 if timerange != None:
696 696 self.timerange = timerange
697 697
698 698 if pairsIndexList == []:
699 699 return
700 700
701 701 if len(pairsIndexList) > 4:
702 702 pairsIndexList = pairsIndexList[0:4]
703 703
704 704 # tmin = None
705 705 # tmax = None
706 706 x = dataOut.getTimeRange()
707 707 y = dataOut.getHeiRange()
708 708
709 709 #thisDatetime = dataOut.datatime
710 710 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
711 711 title = wintitle + " CoherenceMap" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
712 712 xlabel = ""
713 713 ylabel = "Range (Km)"
714 714
715 715 if not self.isConfig:
716 716 nplots = len(pairsIndexList)
717 717 self.setup(id=id,
718 718 nplots=nplots,
719 719 wintitle=wintitle,
720 720 showprofile=showprofile,
721 721 show=show)
722 722
723 #tmin, tmax = self.getTimeLim(x, xmin, xmax, timezone = dataOut.timezone)
723 #tmin, tmax = self.getTimeLim(x, xmin, xmax)
724 724
725 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange, timezone = dataOut.timezone)
725 self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
726 726
727 727 if ymin == None: ymin = numpy.nanmin(y)
728 728 if ymax == None: ymax = numpy.nanmax(y)
729 729 if zmin == None: zmin = 0.
730 730 if zmax == None: zmax = 1.
731 731
732 732 self.FTP_WEI = ftp_wei
733 733 self.EXP_CODE = exp_code
734 734 self.SUB_EXP_CODE = sub_exp_code
735 735 self.PLOT_POS = plot_pos
736 736
737 737 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
738 738
739 739 self.isConfig = True
740 740
741 741 self.setWinTitle(title)
742 742
743 743 if ((self.xmax - x[1]) < (x[1]-x[0])):
744 744 x[1] = self.xmax
745 745
746 746 for i in range(self.nplots):
747 747
748 748 pair = dataOut.pairsList[pairsIndexList[i]]
749 749
750 750 ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
751 751 powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
752 752 powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
753 753
754 754
755 755 avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
756 756 coherence = numpy.abs(avgcoherenceComplex)
757 757
758 758 z = coherence.reshape((1,-1))
759 759
760 760 counter = 0
761 761
762 762 title = "Coherence %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
763 763 axes = self.axesList[i*self.__nsubplots*2]
764 764 axes.pcolorbuffer(x, y, z,
765 765 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
766 766 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
767 767 ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
768 768
769 769 if self.__showprofile:
770 770 counter += 1
771 771 axes = self.axesList[i*self.__nsubplots*2 + counter]
772 772 axes.pline(coherence, y,
773 773 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
774 774 xlabel='', ylabel='', title='', ticksize=7,
775 775 ytick_visible=False, nxticks=5,
776 776 grid='x')
777 777
778 778 counter += 1
779 779
780 780 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
781 781
782 782 z = phase.reshape((1,-1))
783 783
784 784 title = "Phase %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
785 785 axes = self.axesList[i*self.__nsubplots*2 + counter]
786 786 axes.pcolorbuffer(x, y, z,
787 787 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
788 788 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
789 789 ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
790 790
791 791 if self.__showprofile:
792 792 counter += 1
793 793 axes = self.axesList[i*self.__nsubplots*2 + counter]
794 794 axes.pline(phase, y,
795 795 xmin=-180, xmax=180, ymin=ymin, ymax=ymax,
796 796 xlabel='', ylabel='', title='', ticksize=7,
797 797 ytick_visible=False, nxticks=4,
798 798 grid='x')
799 799
800 800 self.draw()
801 801
802 802 if x[1] >= self.axesList[0].xmax:
803 803 self.counter_imagwr = wr_period
804 804 self.__isConfig = False
805 805
806 806 if figfile == None:
807 807 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
808 808 figfile = self.getFilename(name = str_datetime)
809 809
810 810 if figpath != '':
811 811
812 812 self.counter_imagwr += 1
813 813 if (self.counter_imagwr>=wr_period):
814 814 # store png plot to local folder
815 815 self.saveFigure(figpath, figfile)
816 816 # store png plot to FTP server according to RT-Web format
817 817 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
818 818 ftp_filename = os.path.join(figpath, name)
819 819 self.saveFigure(figpath, ftp_filename)
820 820
821 821 self.counter_imagwr = 0
822 822
823 823 class PowerProfile(Figure):
824 824 isConfig = None
825 825 __nsubplots = None
826 826
827 827 WIDTHPROF = None
828 828 HEIGHTPROF = None
829 829 PREFIX = 'spcprofile'
830 830
831 831 def __init__(self):
832 832 self.isConfig = False
833 833 self.__nsubplots = 1
834 834
835 835 self.WIDTH = 300
836 836 self.HEIGHT = 500
837 837 self.counter_imagwr = 0
838 838
839 839 def getSubplots(self):
840 840 ncol = 1
841 841 nrow = 1
842 842
843 843 return nrow, ncol
844 844
845 845 def setup(self, id, nplots, wintitle, show):
846 846
847 847 self.nplots = nplots
848 848
849 849 ncolspan = 1
850 850 colspan = 1
851 851
852 852 self.createFigure(id = id,
853 853 wintitle = wintitle,
854 854 widthplot = self.WIDTH,
855 855 heightplot = self.HEIGHT,
856 856 show=show)
857 857
858 858 nrow, ncol = self.getSubplots()
859 859
860 860 counter = 0
861 861 for y in range(nrow):
862 862 for x in range(ncol):
863 863 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
864 864
865 865 def run(self, dataOut, id, wintitle="", channelList=None,
866 866 xmin=None, xmax=None, ymin=None, ymax=None,
867 867 save=False, figpath='', figfile=None, show=True, wr_period=1,
868 868 server=None, folder=None, username=None, password=None,):
869 869
870 870 if dataOut.flagNoData:
871 871 return None
872 872
873 873 if channelList == None:
874 874 channelIndexList = dataOut.channelIndexList
875 875 channelList = dataOut.channelList
876 876 else:
877 877 channelIndexList = []
878 878 for channel in channelList:
879 879 if channel not in dataOut.channelList:
880 880 raise ValueError, "Channel %d is not in dataOut.channelList"
881 881 channelIndexList.append(dataOut.channelList.index(channel))
882 882
883 883 try:
884 884 factor = dataOut.normFactor
885 885 except:
886 886 factor = 1
887 887
888 888 y = dataOut.getHeiRange()
889 889
890 890 #for voltage
891 891 if dataOut.type == 'Voltage':
892 892 x = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
893 893 x = x.real
894 894 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
895 895
896 896 #for spectra
897 897 if dataOut.type == 'Spectra':
898 898 x = dataOut.data_spc[channelIndexList,:,:]/factor
899 899 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
900 900 x = numpy.average(x, axis=1)
901 901
902 902
903 903 xdB = 10*numpy.log10(x)
904 904
905 905 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
906 906 title = wintitle + " Power Profile %s" %(thisDatetime.strftime("%d-%b-%Y"))
907 907 xlabel = "dB"
908 908 ylabel = "Range (Km)"
909 909
910 910 if not self.isConfig:
911 911
912 912 nplots = 1
913 913
914 914 self.setup(id=id,
915 915 nplots=nplots,
916 916 wintitle=wintitle,
917 917 show=show)
918 918
919 919 if ymin == None: ymin = numpy.nanmin(y)
920 920 if ymax == None: ymax = numpy.nanmax(y)
921 921 if xmin == None: xmin = numpy.nanmin(xdB)*0.9
922 922 if xmax == None: xmax = numpy.nanmax(xdB)*0.9
923 923
924 924 self.__isConfig = True
925 925
926 926 self.setWinTitle(title)
927 927
928 928 title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
929 929 axes = self.axesList[0]
930 930
931 931 legendlabels = ["channel %d"%x for x in channelList]
932 932 axes.pmultiline(xdB, y,
933 933 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
934 934 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
935 935 ytick_visible=True, nxticks=5,
936 936 grid='x')
937 937
938 938 self.draw()
939 939
940 940 if figfile == None:
941 941 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
942 942 figfile = self.getFilename(name = str_datetime)
943 943
944 944 if figpath != '':
945 945 self.counter_imagwr += 1
946 946 if (self.counter_imagwr>=wr_period):
947 947 # store png plot to local folder
948 948 self.saveFigure(figpath, figfile)
949 949 # store png plot to FTP server according to RT-Web format
950 950 #name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
951 951 #ftp_filename = os.path.join(figpath, name)
952 952 #self.saveFigure(figpath, ftp_filename)
953 953 self.counter_imagwr = 0
954 954
955 955
956 956
957 957 class Noise(Figure):
958 958
959 959 isConfig = None
960 960 __nsubplots = None
961 961
962 962 PREFIX = 'noise'
963 963
964 964 def __init__(self):
965 965
966 966 self.timerange = 24*60*60
967 967 self.isConfig = False
968 968 self.__nsubplots = 1
969 969 self.counter_imagwr = 0
970 970 self.WIDTH = 600
971 971 self.HEIGHT = 300
972 972 self.WIDTHPROF = 120
973 973 self.HEIGHTPROF = 0
974 974 self.xdata = None
975 975 self.ydata = None
976 976
977 977 self.PLOT_CODE = 17
978 978 self.FTP_WEI = None
979 979 self.EXP_CODE = None
980 980 self.SUB_EXP_CODE = None
981 981 self.PLOT_POS = None
982 982 self.figfile = None
983 983
984 984 def getSubplots(self):
985 985
986 986 ncol = 1
987 987 nrow = 1
988 988
989 989 return nrow, ncol
990 990
991 991 def openfile(self, filename):
992 992 f = open(filename,'w+')
993 993 f.write('\n\n')
994 994 f.write('JICAMARCA RADIO OBSERVATORY - Noise \n')
995 995 f.write('DD MM YYYY HH MM SS Channel0 Channel1 Channel2 Channel3\n\n' )
996 996 f.close()
997 997
998 998 def save_data(self, filename_phase, data, data_datetime):
999 999 f=open(filename_phase,'a')
1000 1000 timetuple_data = data_datetime.timetuple()
1001 1001 day = str(timetuple_data.tm_mday)
1002 1002 month = str(timetuple_data.tm_mon)
1003 1003 year = str(timetuple_data.tm_year)
1004 1004 hour = str(timetuple_data.tm_hour)
1005 1005 minute = str(timetuple_data.tm_min)
1006 1006 second = str(timetuple_data.tm_sec)
1007 1007 f.write(day+' '+month+' '+year+' '+hour+' '+minute+' '+second+' '+str(data[0])+' '+str(data[1])+' '+str(data[2])+' '+str(data[3])+'\n')
1008 1008 f.close()
1009 1009
1010 1010
1011 1011 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1012 1012
1013 1013 self.__showprofile = showprofile
1014 1014 self.nplots = nplots
1015 1015
1016 1016 ncolspan = 7
1017 1017 colspan = 6
1018 1018 self.__nsubplots = 2
1019 1019
1020 1020 self.createFigure(id = id,
1021 1021 wintitle = wintitle,
1022 1022 widthplot = self.WIDTH+self.WIDTHPROF,
1023 1023 heightplot = self.HEIGHT+self.HEIGHTPROF,
1024 1024 show=show)
1025 1025
1026 1026 nrow, ncol = self.getSubplots()
1027 1027
1028 1028 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1029 1029
1030 1030
1031 1031 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
1032 1032 xmin=None, xmax=None, ymin=None, ymax=None,
1033 1033 timerange=None,
1034 1034 save=False, figpath='', figfile=None, show=True, ftp=False, wr_period=1,
1035 1035 server=None, folder=None, username=None, password=None,
1036 1036 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1037 1037
1038 1038 if channelList == None:
1039 1039 channelIndexList = dataOut.channelIndexList
1040 1040 channelList = dataOut.channelList
1041 1041 else:
1042 1042 channelIndexList = []
1043 1043 for channel in channelList:
1044 1044 if channel not in dataOut.channelList:
1045 1045 raise ValueError, "Channel %d is not in dataOut.channelList"
1046 1046 channelIndexList.append(dataOut.channelList.index(channel))
1047 1047
1048 1048 if timerange != None:
1049 1049 self.timerange = timerange
1050 1050
1051 1051 tmin = None
1052 1052 tmax = None
1053 1053 x = dataOut.getTimeRange()
1054 1054 y = dataOut.getHeiRange()
1055 1055 factor = dataOut.normFactor
1056 1056 noise = dataOut.noise/factor
1057 1057 noisedB = 10*numpy.log10(noise)
1058 1058
1059 1059 #thisDatetime = dataOut.datatime
1060 1060 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
1061 1061 title = wintitle + " Noise" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
1062 1062 xlabel = ""
1063 1063 ylabel = "Intensity (dB)"
1064 1064
1065 1065 if not self.isConfig:
1066 1066
1067 1067 nplots = 1
1068 1068
1069 1069 self.setup(id=id,
1070 1070 nplots=nplots,
1071 1071 wintitle=wintitle,
1072 1072 showprofile=showprofile,
1073 1073 show=show)
1074 1074
1075 tmin, tmax = self.getTimeLim(x, xmin, xmax, timezone = dataOut.timezone)
1075 tmin, tmax = self.getTimeLim(x, xmin, xmax)
1076 1076 if ymin == None: ymin = numpy.nanmin(noisedB) - 10.0
1077 1077 if ymax == None: ymax = numpy.nanmax(noisedB) + 10.0
1078 1078
1079 1079 self.FTP_WEI = ftp_wei
1080 1080 self.EXP_CODE = exp_code
1081 1081 self.SUB_EXP_CODE = sub_exp_code
1082 1082 self.PLOT_POS = plot_pos
1083 1083
1084 1084
1085 1085 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1086 1086 self.isConfig = True
1087 1087 self.figfile = figfile
1088 1088 self.xdata = numpy.array([])
1089 1089 self.ydata = numpy.array([])
1090 1090
1091 1091 #open file beacon phase
1092 1092 path = '%s%03d' %(self.PREFIX, self.id)
1093 1093 noise_file = os.path.join(path,'%s.txt'%self.name)
1094 1094 self.filename_noise = os.path.join(figpath,noise_file)
1095 1095 self.openfile(self.filename_noise)
1096 1096
1097 1097
1098 1098 #store data beacon phase
1099 1099 self.save_data(self.filename_noise, noisedB, thisDatetime)
1100 1100
1101 1101
1102 1102 self.setWinTitle(title)
1103 1103
1104 1104
1105 1105 title = "Noise %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1106 1106
1107 1107 legendlabels = ["channel %d"%(idchannel+1) for idchannel in channelList]
1108 1108 axes = self.axesList[0]
1109 1109
1110 1110 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1111 1111
1112 1112 if len(self.ydata)==0:
1113 1113 self.ydata = noisedB[channelIndexList].reshape(-1,1)
1114 1114 else:
1115 1115 self.ydata = numpy.hstack((self.ydata, noisedB[channelIndexList].reshape(-1,1)))
1116 1116
1117 1117
1118 1118 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1119 1119 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
1120 1120 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1121 1121 XAxisAsTime=True, grid='both'
1122 1122 )
1123 1123
1124 1124 self.draw()
1125 1125
1126 1126 if x[1] >= self.axesList[0].xmax:
1127 1127 self.counter_imagwr = wr_period
1128 1128 del self.xdata
1129 1129 del self.ydata
1130 1130 self.__isConfig = False
1131 1131
1132 1132 if self.figfile == None:
1133 1133 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
1134 1134 self.figfile = self.getFilename(name = str_datetime)
1135 1135
1136 1136 if figpath != '':
1137 1137 self.counter_imagwr += 1
1138 1138 if (self.counter_imagwr>=wr_period):
1139 1139 # store png plot to local folder
1140 1140 self.saveFigure(figpath, self.figfile)
1141 1141 # store png plot to FTP server according to RT-Web format
1142 1142 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
1143 1143 ftp_filename = os.path.join(figpath, name)
1144 1144 self.saveFigure(figpath, ftp_filename)
1145 1145 self.counter_imagwr = 0
1146 1146
1147 1147
1148 1148 class BeaconPhase(Figure):
1149 1149
1150 1150 __isConfig = None
1151 1151 __nsubplots = None
1152 1152
1153 1153 PREFIX = 'beacon_phase'
1154 1154
1155 1155 def __init__(self):
1156 1156
1157 1157 self.timerange = 24*60*60
1158 1158 self.__isConfig = False
1159 1159 self.__nsubplots = 1
1160 1160 self.counter_imagwr = 0
1161 1161 self.WIDTH = 600
1162 1162 self.HEIGHT = 300
1163 1163 self.WIDTHPROF = 120
1164 1164 self.HEIGHTPROF = 0
1165 1165 self.xdata = None
1166 1166 self.ydata = None
1167 1167
1168 1168 self.PLOT_CODE = 18
1169 1169 self.FTP_WEI = None
1170 1170 self.EXP_CODE = None
1171 1171 self.SUB_EXP_CODE = None
1172 1172 self.PLOT_POS = None
1173 1173
1174 1174 self.filename_phase = None
1175 1175
1176 1176 self.figfile = None
1177 1177
1178 1178 def getSubplots(self):
1179 1179
1180 1180 ncol = 1
1181 1181 nrow = 1
1182 1182
1183 1183 return nrow, ncol
1184 1184
1185 1185 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
1186 1186
1187 1187 self.__showprofile = showprofile
1188 1188 self.nplots = nplots
1189 1189
1190 1190 ncolspan = 7
1191 1191 colspan = 6
1192 1192 self.__nsubplots = 2
1193 1193
1194 1194 self.createFigure(id = id,
1195 1195 wintitle = wintitle,
1196 1196 widthplot = self.WIDTH+self.WIDTHPROF,
1197 1197 heightplot = self.HEIGHT+self.HEIGHTPROF,
1198 1198 show=show)
1199 1199
1200 1200 nrow, ncol = self.getSubplots()
1201 1201
1202 1202 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
1203 1203
1204 1204 def save_phase(self, filename_phase):
1205 1205 f = open(filename_phase,'w+')
1206 1206 f.write('\n\n')
1207 1207 f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
1208 1208 f.write('DD MM YYYY HH MM SS pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
1209 1209 f.close()
1210 1210
1211 1211 def save_data(self, filename_phase, data, data_datetime):
1212 1212 f=open(filename_phase,'a')
1213 1213 timetuple_data = data_datetime.timetuple()
1214 1214 day = str(timetuple_data.tm_mday)
1215 1215 month = str(timetuple_data.tm_mon)
1216 1216 year = str(timetuple_data.tm_year)
1217 1217 hour = str(timetuple_data.tm_hour)
1218 1218 minute = str(timetuple_data.tm_min)
1219 1219 second = str(timetuple_data.tm_sec)
1220 1220 f.write(day+' '+month+' '+year+' '+hour+' '+minute+' '+second+' '+str(data[0])+' '+str(data[1])+' '+str(data[2])+' '+str(data[3])+'\n')
1221 1221 f.close()
1222 1222
1223 1223
1224 1224 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
1225 1225 xmin=None, xmax=None, ymin=None, ymax=None,
1226 1226 timerange=None,
1227 1227 save=False, figpath='', figfile=None, show=True, ftp=False, wr_period=1,
1228 1228 server=None, folder=None, username=None, password=None,
1229 1229 ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
1230 1230
1231 1231 if pairsList == None:
1232 1232 pairsIndexList = dataOut.pairsIndexList
1233 1233 else:
1234 1234 pairsIndexList = []
1235 1235 for pair in pairsList:
1236 1236 if pair not in dataOut.pairsList:
1237 1237 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
1238 1238 pairsIndexList.append(dataOut.pairsList.index(pair))
1239 1239
1240 1240 if pairsIndexList == []:
1241 1241 return
1242 1242
1243 1243 # if len(pairsIndexList) > 4:
1244 1244 # pairsIndexList = pairsIndexList[0:4]
1245 1245
1246 1246 if timerange != None:
1247 1247 self.timerange = timerange
1248 1248
1249 1249 tmin = None
1250 1250 tmax = None
1251 1251 x = dataOut.getTimeRange()
1252 1252 y = dataOut.getHeiRange()
1253 1253
1254 1254
1255 1255 #thisDatetime = dataOut.datatime
1256 1256 thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[1])
1257 1257 title = wintitle + " Phase of Beacon Signal" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
1258 1258 xlabel = "Local Time"
1259 1259 ylabel = "Phase"
1260 1260
1261 1261 nplots = len(pairsIndexList)
1262 1262 #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
1263 1263 phase_beacon = numpy.zeros(len(pairsIndexList))
1264 1264 for i in range(nplots):
1265 1265 pair = dataOut.pairsList[pairsIndexList[i]]
1266 1266 ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
1267 1267 powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
1268 1268 powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
1269 1269 avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
1270 1270 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
1271 1271
1272 1272 #print "Phase %d%d" %(pair[0], pair[1])
1273 1273 #print phase[dataOut.beacon_heiIndexList]
1274 1274
1275 1275 phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
1276 1276
1277 1277 if not self.__isConfig:
1278 1278
1279 1279 nplots = len(pairsIndexList)
1280 1280
1281 1281 self.setup(id=id,
1282 1282 nplots=nplots,
1283 1283 wintitle=wintitle,
1284 1284 showprofile=showprofile,
1285 1285 show=show)
1286 1286
1287 tmin, tmax = self.getTimeLim(x, xmin, xmax, timezone = dataOut.timezone)
1287 tmin, tmax = self.getTimeLim(x, xmin, xmax)
1288 1288 if ymin == None: ymin = numpy.nanmin(phase_beacon) - 10.0
1289 1289 if ymax == None: ymax = numpy.nanmax(phase_beacon) + 10.0
1290 1290
1291 1291 self.FTP_WEI = ftp_wei
1292 1292 self.EXP_CODE = exp_code
1293 1293 self.SUB_EXP_CODE = sub_exp_code
1294 1294 self.PLOT_POS = plot_pos
1295 1295
1296 1296 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
1297 1297 self.__isConfig = True
1298 1298 self.figfile = figfile
1299 1299 self.xdata = numpy.array([])
1300 1300 self.ydata = numpy.array([])
1301 1301
1302 1302 #open file beacon phase
1303 1303 path = '%s%03d' %(self.PREFIX, self.id)
1304 1304 beacon_file = os.path.join(path,'%s.txt'%self.name)
1305 1305 self.filename_phase = os.path.join(figpath,beacon_file)
1306 1306 #self.save_phase(self.filename_phase)
1307 1307
1308 1308
1309 1309 #store data beacon phase
1310 1310 #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
1311 1311
1312 1312 self.setWinTitle(title)
1313 1313
1314 1314
1315 1315 title = "Beacon Signal %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
1316 1316
1317 1317 legendlabels = ["pairs %d%d"%(pair[0], pair[1]) for pair in dataOut.pairsList]
1318 1318
1319 1319 axes = self.axesList[0]
1320 1320
1321 1321 self.xdata = numpy.hstack((self.xdata, x[0:1]))
1322 1322
1323 1323 if len(self.ydata)==0:
1324 1324 self.ydata = phase_beacon.reshape(-1,1)
1325 1325 else:
1326 1326 self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
1327 1327
1328 1328
1329 1329 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
1330 1330 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
1331 1331 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
1332 1332 XAxisAsTime=True, grid='both'
1333 1333 )
1334 1334
1335 1335 self.draw()
1336 1336
1337 1337 if x[1] >= self.axesList[0].xmax:
1338 1338 self.counter_imagwr = wr_period
1339 1339 del self.xdata
1340 1340 del self.ydata
1341 1341 self.__isConfig = False
1342 1342
1343 1343 if self.figfile == None:
1344 1344 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
1345 1345 self.figfile = self.getFilename(name = str_datetime)
1346 1346
1347 1347 if figpath != '':
1348 1348 self.counter_imagwr += 1
1349 1349 if (self.counter_imagwr>=wr_period):
1350 1350 # store png plot to local folder
1351 1351 self.saveFigure(figpath, self.figfile)
1352 1352 # store png plot to FTP server according to RT-Web format
1353 1353 name = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
1354 1354 ftp_filename = os.path.join(figpath, name)
1355 1355 self.saveFigure(figpath, ftp_filename)
1356 1356 self.counter_imagwr = 0
General Comments 0
You need to be logged in to leave comments. Login now