source: branches/Release2.1.2/python/asapplotter.py@ 2863

Last change on this file since 2863 was 1320, checked in by mar637, 18 years ago

merge from trunk, to get most recent bug fixes

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 28.9 KB
Line 
1from asap import rcParams, print_log, selector
2import matplotlib.axes
3import re
4
5class asapplotter:
6 """
7 The ASAP plotter.
8 By default the plotter is set up to plot polarisations
9 'colour stacked' and scantables across panels.
10 Note:
11 Currenly it only plots 'spectra' not Tsys or
12 other variables.
13 """
14 def __init__(self, visible=None):
15 self._visible = rcParams['plotter.gui']
16 if visible is not None:
17 self._visible = visible
18 self._plotter = self._newplotter()
19
20 self._panelling = None
21 self._stacking = None
22 self.set_panelling()
23 self.set_stacking()
24 self._rows = None
25 self._cols = None
26 self._autoplot = False
27 self._minmaxx = None
28 self._minmaxy = None
29 self._datamask = None
30 self._data = None
31 self._lmap = None
32 self._title = None
33 self._ordinate = None
34 self._abcissa = None
35 self._abcunit = None
36 self._usermask = []
37 self._maskselection = None
38 self._selection = selector()
39 self._hist = rcParams['plotter.histogram']
40
41 def _translate(self, instr):
42 keys = "s b i p t".split()
43 if isinstance(instr, str):
44 for key in keys:
45 if instr.lower().startswith(key):
46 return key
47 return None
48
49 def _newplotter(self):
50 if self._visible:
51 from asap.asaplotgui import asaplotgui as asaplot
52 else:
53 from asap.asaplot import asaplot
54 return asaplot()
55
56
57 def plot(self, scan=None):
58 """
59 Plot a scantable.
60 Parameters:
61 scan: a scantable
62 Note:
63 If a scantable was specified in a previous call
64 to plot, no argument has to be given to 'replot'
65 NO checking is done that the abcissas of the scantable
66 are consistent e.g. all 'channel' or all 'velocity' etc.
67 """
68 if self._plotter.is_dead:
69 self._plotter = self._newplotter()
70 self._plotter.hold()
71 self._plotter.clear()
72 from asap import scantable
73 if not self._data and not scan:
74 msg = "Input is not a scantable"
75 if rcParams['verbose']:
76 print msg
77 return
78 raise TypeError(msg)
79 if isinstance(scan, scantable):
80 if self._data is not None:
81 if scan != self._data:
82 self._data = scan
83 # reset
84 self._reset()
85 else:
86 self._data = scan
87 self._reset()
88 # ranges become invalid when unit changes
89 if self._abcunit and self._abcunit != self._data.get_unit():
90 self._minmaxx = None
91 self._minmaxy = None
92 self._abcunit = self._data.get_unit()
93 self._datamask = None
94 self._plot(self._data)
95 if self._minmaxy is not None:
96 self._plotter.set_limits(ylim=self._minmaxy)
97 self._plotter.release()
98 self._plotter.tidy()
99 self._plotter.show(hardrefresh=False)
100 print_log()
101 return
102
103
104 # forwards to matplotlib axes
105 def text(self, *args, **kwargs):
106 self._axes_callback("text", *args, **kwargs)
107 text. __doc__ = matplotlib.axes.Axes.text.__doc__
108 def arrow(self, *args, **kwargs):
109 self._axes_callback("arrow", *args, **kwargs)
110 arrow. __doc__ = matplotlib.axes.Axes.arrow.__doc__
111 def axvline(self, *args, **kwargs):
112 self._axes_callback("axvline", *args, **kwargs)
113 axvline. __doc__ = matplotlib.axes.Axes.axvline.__doc__
114 def axhline(self, *args, **kwargs):
115 self._axes_callback("axhline", *args, **kwargs)
116 axhline. __doc__ = matplotlib.axes.Axes.axhline.__doc__
117 def axvspan(self, *args, **kwargs):
118 self._axes_callback("axvspan", *args, **kwargs)
119 # hack to preventy mpl from redrawing the patch
120 # it seem to convert the patch into lines on every draw.
121 # This doesn't happen in a test script???
122 del self._plotter.axes.patches[-1]
123 axvspan. __doc__ = matplotlib.axes.Axes.axvspan.__doc__
124
125 def axhspan(self, *args, **kwargs):
126 self._axes_callback("axhspan", *args, **kwargs)
127 # hack to preventy mpl from redrawing the patch
128 # it seem to convert the patch into lines on every draw.
129 # This doesn't happen in a test script???
130 del self._plotter.axes.patches[-1]
131 axhspan. __doc__ = matplotlib.axes.Axes.axhspan.__doc__
132
133 def _axes_callback(self, axesfunc, *args, **kwargs):
134 panel = 0
135 if kwargs.has_key("panel"):
136 panel = kwargs.pop("panel")
137 coords = None
138 if kwargs.has_key("coords"):
139 coords = kwargs.pop("coords")
140 if coords.lower() == 'world':
141 kwargs["transform"] = self._plotter.axes.transData
142 elif coords.lower() == 'relative':
143 kwargs["transform"] = self._plotter.axes.transAxes
144 self._plotter.subplot(panel)
145 self._plotter.axes.set_autoscale_on(False)
146 getattr(self._plotter.axes, axesfunc)(*args, **kwargs)
147 self._plotter.show(False)
148 self._plotter.axes.set_autoscale_on(True)
149 # end matplotlib.axes fowarding functions
150
151 def set_mode(self, stacking=None, panelling=None):
152 """
153 Set the plots look and feel, i.e. what you want to see on the plot.
154 Parameters:
155 stacking: tell the plotter which variable to plot
156 as line colour overlays (default 'pol')
157 panelling: tell the plotter which variable to plot
158 across multiple panels (default 'scan'
159 Note:
160 Valid modes are:
161 'beam' 'Beam' 'b': Beams
162 'if' 'IF' 'i': IFs
163 'pol' 'Pol' 'p': Polarisations
164 'scan' 'Scan' 's': Scans
165 'time' 'Time' 't': Times
166 """
167 msg = "Invalid mode"
168 if not self.set_panelling(panelling) or \
169 not self.set_stacking(stacking):
170 if rcParams['verbose']:
171 print msg
172 return
173 else:
174 raise TypeError(msg)
175 if self._data: self.plot(self._data)
176 return
177
178 def set_panelling(self, what=None):
179 mode = what
180 if mode is None:
181 mode = rcParams['plotter.panelling']
182 md = self._translate(mode)
183 if md:
184 self._panelling = md
185 self._title = None
186 return True
187 return False
188
189 def set_layout(self,rows=None,cols=None):
190 """
191 Set the multi-panel layout, i.e. how many rows and columns plots
192 are visible.
193 Parameters:
194 rows: The number of rows of plots
195 cols: The number of columns of plots
196 Note:
197 If no argument is given, the potter reverts to its auto-plot
198 behaviour.
199 """
200 self._rows = rows
201 self._cols = cols
202 if self._data: self.plot(self._data)
203 return
204
205 def set_stacking(self, what=None):
206 mode = what
207 if mode is None:
208 mode = rcParams['plotter.stacking']
209 md = self._translate(mode)
210 if md:
211 self._stacking = md
212 self._lmap = None
213 return True
214 return False
215
216 def set_range(self,xstart=None,xend=None,ystart=None,yend=None):
217 """
218 Set the range of interest on the abcissa of the plot
219 Parameters:
220 [x,y]start,[x,y]end: The start and end points of the 'zoom' window
221 Note:
222 These become non-sensical when the unit changes.
223 use plotter.set_range() without parameters to reset
224
225 """
226 if xstart is None and xend is None:
227 self._minmaxx = None
228 else:
229 self._minmaxx = [xstart,xend]
230 if ystart is None and yend is None:
231 self._minmaxy = None
232 else:
233 self._minmaxy = [ystart,yend]
234 if self._data: self.plot(self._data)
235 return
236
237 def set_legend(self, mp=None, fontsize = None, mode = 0):
238 """
239 Specify a mapping for the legend instead of using the default
240 indices:
241 Parameters:
242 mp: a list of 'strings'. This should have the same length
243 as the number of elements on the legend and then maps
244 to the indeces in order. It is possible to uses latex
245 math expression. These have to be enclosed in r'',
246 e.g. r'$x^{2}$'
247 fontsize: The font size of the label (default None)
248 mode: where to display the legend
249 Any other value for loc else disables the legend:
250 0: auto
251 1: upper right
252 2: upper left
253 3: lower left
254 4: lower right
255 5: right
256 6: center left
257 7: center right
258 8: lower center
259 9: upper center
260 10: center
261
262 Example:
263 If the data has two IFs/rest frequencies with index 0 and 1
264 for CO and SiO:
265 plotter.set_stacking('i')
266 plotter.set_legend(['CO','SiO'])
267 plotter.plot()
268 plotter.set_legend([r'$^{12}CO$', r'SiO'])
269 """
270 self._lmap = mp
271 self._plotter.legend(mode)
272 if isinstance(fontsize, int):
273 from matplotlib import rc as rcp
274 rcp('legend', fontsize=fontsize)
275 if self._data:
276 self.plot(self._data)
277 return
278
279 def set_title(self, title=None, fontsize=None):
280 """
281 Set the title of the plot. If multiple panels are plotted,
282 multiple titles have to be specified.
283 Example:
284 # two panels are visible on the plotter
285 plotter.set_title(["First Panel","Second Panel"])
286 """
287 self._title = title
288 if isinstance(fontsize, int):
289 from matplotlib import rc as rcp
290 rcp('axes', titlesize=fontsize)
291 if self._data: self.plot(self._data)
292 return
293
294 def set_ordinate(self, ordinate=None, fontsize=None):
295 """
296 Set the y-axis label of the plot. If multiple panels are plotted,
297 multiple labels have to be specified.
298 Parameters:
299 ordinate: a list of ordinate labels. None (default) let
300 data determine the labels
301 Example:
302 # two panels are visible on the plotter
303 plotter.set_ordinate(["First Y-Axis","Second Y-Axis"])
304 """
305 self._ordinate = ordinate
306 if isinstance(fontsize, int):
307 from matplotlib import rc as rcp
308 rcp('axes', labelsize=fontsize)
309 rcp('ytick', labelsize=fontsize)
310 if self._data: self.plot(self._data)
311 return
312
313 def set_abcissa(self, abcissa=None, fontsize=None):
314 """
315 Set the x-axis label of the plot. If multiple panels are plotted,
316 multiple labels have to be specified.
317 Parameters:
318 abcissa: a list of abcissa labels. None (default) let
319 data determine the labels
320 Example:
321 # two panels are visible on the plotter
322 plotter.set_ordinate(["First X-Axis","Second X-Axis"])
323 """
324 self._abcissa = abcissa
325 if isinstance(fontsize, int):
326 from matplotlib import rc as rcp
327 rcp('axes', labelsize=fontsize)
328 rcp('xtick', labelsize=fontsize)
329 if self._data: self.plot(self._data)
330 return
331
332 def set_colors(self, colmap):
333 """
334 Set the colours to be used. The plotter will cycle through
335 these colours when lines are overlaid (stacking mode).
336 Parameters:
337 colmap: a list of colour names
338 Example:
339 plotter.set_colors("red green blue")
340 # If for example four lines are overlaid e.g I Q U V
341 # 'I' will be 'red', 'Q' will be 'green', U will be 'blue'
342 # and 'V' will be 'red' again.
343 """
344 if isinstance(colmap,str):
345 colmap = colmap.split()
346 self._plotter.palette(0, colormap=colmap)
347 if self._data: self.plot(self._data)
348
349 # alias for english speakers
350 set_colours = set_colors
351
352 def set_histogram(self, hist=True, linewidth=None):
353 """
354 Enable/Disable histogram-like plotting.
355 Parameters:
356 hist: True (default) or False. The fisrt default
357 is taken from the .asaprc setting
358 plotter.histogram
359 """
360 self._hist = hist
361 if isinstance(linewidth, float) or isinstance(linewidth, int):
362 from matplotlib import rc as rcp
363 rcp('lines', linewidth=linewidth)
364 if self._data: self.plot(self._data)
365
366 def set_linestyles(self, linestyles=None, linewidth=None):
367 """
368 Set the linestyles to be used. The plotter will cycle through
369 these linestyles when lines are overlaid (stacking mode) AND
370 only one color has been set.
371 Parameters:
372 linestyles: a list of linestyles to use.
373 'line', 'dashed', 'dotted', 'dashdot',
374 'dashdotdot' and 'dashdashdot' are
375 possible
376
377 Example:
378 plotter.set_colors("black")
379 plotter.set_linestyles("line dashed dotted dashdot")
380 # If for example four lines are overlaid e.g I Q U V
381 # 'I' will be 'solid', 'Q' will be 'dashed',
382 # U will be 'dotted' and 'V' will be 'dashdot'.
383 """
384 if isinstance(linestyles,str):
385 linestyles = linestyles.split()
386 self._plotter.palette(color=0,linestyle=0,linestyles=linestyles)
387 if isinstance(linewidth, float) or isinstance(linewidth, int):
388 from matplotlib import rc as rcp
389 rcp('lines', linewidth=linewidth)
390 if self._data: self.plot(self._data)
391
392 def set_font(self, family=None, style=None, weight=None, size=None):
393 """
394 Set font properties.
395 Parameters:
396 family: one of 'sans-serif', 'serif', 'cursive', 'fantasy', 'monospace'
397 style: one of 'normal' (or 'roman'), 'italic' or 'oblique'
398 weight: one of 'normal or 'bold'
399 size: the 'general' font size, individual elements can be adjusted
400 seperately
401 """
402 from matplotlib import rc as rcp
403 if isinstance(family, str):
404 rcp('font', family=family)
405 if isinstance(style, str):
406 rcp('font', style=style)
407 if isinstance(weight, str):
408 rcp('font', weight=weight)
409 if isinstance(size, float) or isinstance(size, int):
410 rcp('font', size=size)
411 if self._data: self.plot(self._data)
412
413 def plot_lines(self, linecat=None, doppler=0.0, deltachan=10, rotate=90.0,
414 location=None):
415 """
416 Plot a line catalog.
417 Parameters:
418 linecat: the linecatalog to plot
419 doppler: the velocity shift to apply to the frequencies
420 deltachan: the number of channels to include each side of the
421 line to determine a local maximum/minimum
422 rotate: the rotation (in degrees) )for the text label (default 90.0)
423 location: the location of the line annotation from the 'top',
424 'bottom' or alternate (None - the default)
425 Notes:
426 If the spectrum is flagged no line will be drawn in that location.
427 """
428 if not self._data:
429 raise RuntimeError("No scantable has been plotted yet.")
430 from asap._asap import linecatalog
431 if not isinstance(linecat, linecatalog):
432 raise ValueError("'linecat' isn't of type linecatalog.")
433 if not self._data.get_unit().endswith("Hz"):
434 raise RuntimeError("Can only overlay linecatalogs when data is in frequency.")
435 from matplotlib.numerix import ma
436 for j in range(len(self._plotter.subplots)):
437 self._plotter.subplot(j)
438 lims = self._plotter.axes.get_xlim()
439 for row in range(linecat.nrow()):
440 # get_frequency returns MHz
441 base = { "GHz": 1000.0, "MHz": 1.0, "Hz": 1.0e-6 }
442 restf = linecat.get_frequency(row)/base[self._data.get_unit()]
443 c = 299792.458
444 freq = restf*(1.0-doppler/c)
445 if lims[0] < freq < lims[1]:
446 if location is None:
447 loc = 'bottom'
448 if row%2: loc='top'
449 else: loc = location
450 maxys = []
451 for line in self._plotter.axes.lines:
452 v = line._x
453 asc = v[0] < v[-1]
454
455 idx = None
456 if not asc:
457 if v[len(v)-1] <= freq <= v[0]:
458 i = len(v)-1
459 while i>=0 and v[i] < freq:
460 idx = i
461 i-=1
462 else:
463 if v[0] <= freq <= v[len(v)-1]:
464 i = 0
465 while i<len(v) and v[i] < freq:
466 idx = i
467 i+=1
468 if idx is not None:
469 lower = idx - deltachan
470 upper = idx + deltachan
471 if lower < 0: lower = 0
472 if upper > len(v): upper = len(v)
473 s = slice(lower, upper)
474 y = line._y[s]
475 maxy = ma.maximum(y)
476 if isinstance( maxy, float):
477 maxys.append(maxy)
478 if len(maxys):
479 peak = max(maxys)
480 if peak > self._plotter.axes.get_ylim()[1]:
481 loc = 'bottom'
482 else:
483 continue
484 self._plotter.vline_with_label(freq, peak,
485 linecat.get_name(row),
486 location=loc, rotate=rotate)
487 self._plotter.show(hardrefresh=False)
488
489
490 def save(self, filename=None, orientation=None, dpi=None):
491 """
492 Save the plot to a file. The know formats are 'png', 'ps', 'eps'.
493 Parameters:
494 filename: The name of the output file. This is optional
495 and autodetects the image format from the file
496 suffix. If non filename is specified a file
497 called 'yyyymmdd_hhmmss.png' is created in the
498 current directory.
499 orientation: optional parameter for postscript only (not eps).
500 'landscape', 'portrait' or None (default) are valid.
501 If None is choosen for 'ps' output, the plot is
502 automatically oriented to fill the page.
503 dpi: The dpi of the output non-ps plot
504 """
505 self._plotter.save(filename,orientation,dpi)
506 return
507
508
509 def set_mask(self, mask=None, selection=None):
510 """
511 Set a plotting mask for a specific polarization.
512 This is useful for masking out "noise" Pangle outside a source.
513 Parameters:
514 mask: a mask from scantable.create_mask
515 selection: the spectra to apply the mask to.
516 Example:
517 select = selector()
518 select.setpolstrings("Pangle")
519 plotter.set_mask(mymask, select)
520 """
521 if not self._data:
522 msg = "Can only set mask after a first call to plot()"
523 if rcParams['verbose']:
524 print msg
525 return
526 else:
527 raise RuntimeError(msg)
528 if len(mask):
529 if isinstance(mask, list) or isinstance(mask, tuple):
530 self._usermask = array(mask)
531 else:
532 self._usermask = mask
533 if mask is None and selection is None:
534 self._usermask = []
535 self._maskselection = None
536 if isinstance(selection, selector):
537 self._maskselection = {'b': selection.get_beams(),
538 's': selection.get_scans(),
539 'i': selection.get_ifs(),
540 'p': selection.get_pols(),
541 't': [] }
542 else:
543 self._maskselection = None
544 self.plot(self._data)
545
546 def _slice_indeces(self, data):
547 mn = self._minmaxx[0]
548 mx = self._minmaxx[1]
549 asc = data[0] < data[-1]
550 start=0
551 end = len(data)-1
552 inc = 1
553 if not asc:
554 start = len(data)-1
555 end = 0
556 inc = -1
557 # find min index
558 while start > 0 and data[start] < mn:
559 start+= inc
560 # find max index
561 while end > 0 and data[end] > mx:
562 end-=inc
563 if end > 0: end +=1
564 if start > end:
565 return end,start
566 return start,end
567
568 def _reset(self):
569 self._usermask = []
570 self._usermaskspectra = None
571 self.set_selection(None, False)
572
573 def _plot(self, scan):
574 savesel = scan.get_selection()
575 sel = savesel + self._selection
576 d0 = {'s': 'SCANNO', 'b': 'BEAMNO', 'i':'IFNO',
577 'p': 'POLNO', 'c': 'CYCLENO', 't' : 'TIME' }
578 order = [d0[self._panelling],d0[self._stacking]]
579 sel.set_order(order)
580 scan.set_selection(sel)
581 d = {'b': scan.getbeam, 's': scan.getscan,
582 'i': scan.getif, 'p': scan.getpol, 't': scan._gettime }
583
584 polmodes = dict(zip(self._selection.get_pols(),
585 self._selection.get_poltypes()))
586 # this returns either a tuple of numbers or a length (ncycles)
587 # convert this into lengths
588 n0,nstack0 = self._get_selected_n(scan)
589 if isinstance(n0, int): n = n0
590 else: n = len(n0)
591 if isinstance(nstack0, int): nstack = nstack0
592 else: nstack = len(nstack0)
593 maxpanel, maxstack = 16,8
594 if n > maxpanel or nstack > maxstack:
595 from asap import asaplog
596 maxn = 0
597 if nstack > maxstack: maxn = maxstack
598 if n > maxpanel: maxn = maxpanel
599 msg ="Scan to be plotted contains more than %d selections.\n" \
600 "Selecting first %d selections..." % (maxn, maxn)
601 asaplog.push(msg)
602 print_log()
603 n = min(n,maxpanel)
604 nstack = min(nstack,maxstack)
605 if n > 1:
606 ganged = rcParams['plotter.ganged']
607 if self._rows and self._cols:
608 n = min(n,self._rows*self._cols)
609 self._plotter.set_panels(rows=self._rows,cols=self._cols,
610 nplots=n,ganged=ganged)
611 else:
612 self._plotter.set_panels(rows=n,cols=0,nplots=n,ganged=ganged)
613 else:
614 self._plotter.set_panels()
615 r=0
616 nr = scan.nrow()
617 a0,b0 = -1,-1
618 allxlim = []
619 allylim = []
620 newpanel=True
621 panelcount,stackcount = 0,0
622 while r < nr:
623 a = d[self._panelling](r)
624 b = d[self._stacking](r)
625 if a > a0 and panelcount < n:
626 if n > 1:
627 self._plotter.subplot(panelcount)
628 self._plotter.palette(0)
629 #title
630 xlab = self._abcissa and self._abcissa[panelcount] \
631 or scan._getabcissalabel()
632 ylab = self._ordinate and self._ordinate[panelcount] \
633 or scan._get_ordinate_label()
634 self._plotter.set_axes('xlabel',xlab)
635 self._plotter.set_axes('ylabel',ylab)
636 lbl = self._get_label(scan, r, self._panelling, self._title)
637 if isinstance(lbl, list) or isinstance(lbl, tuple):
638 if 0 <= panelcount < len(lbl):
639 lbl = lbl[panelcount]
640 else:
641 # get default label
642 lbl = self._get_label(scan, r, self._panelling, None)
643 self._plotter.set_axes('title',lbl)
644 newpanel = True
645 stackcount =0
646 panelcount += 1
647 if (b > b0 or newpanel) and stackcount < nstack:
648 y = []
649 if len(polmodes):
650 y = scan._getspectrum(r, polmodes[scan.getpol(r)])
651 else:
652 y = scan._getspectrum(r)
653 m = scan._getmask(r)
654 from matplotlib.numerix import logical_not, logical_and
655 if self._maskselection and len(self._usermask) == len(m):
656 if d[self._stacking](r) in self._maskselection[self._stacking]:
657 m = logical_and(m, self._usermask)
658 x = scan._getabcissa(r)
659 from matplotlib.numerix import ma, array
660 y = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
661 if self._minmaxx is not None:
662 s,e = self._slice_indeces(x)
663 x = x[s:e]
664 y = y[s:e]
665 if len(x) > 1024 and rcParams['plotter.decimate']:
666 fac = len(x)/1024
667 x = x[::fac]
668 y = y[::fac]
669 llbl = self._get_label(scan, r, self._stacking, self._lmap)
670 if isinstance(llbl, list) or isinstance(llbl, tuple):
671 if 0 <= stackcount < len(llbl):
672 # use user label
673 llbl = llbl[stackcount]
674 else:
675 # get default label
676 llbl = self._get_label(scan, r, self._stacking, None)
677 self._plotter.set_line(label=llbl)
678 plotit = self._plotter.plot
679 if self._hist: plotit = self._plotter.hist
680 if len(x) > 0:
681 plotit(x,y)
682 xlim= self._minmaxx or [min(x),max(x)]
683 allxlim += xlim
684 ylim= self._minmaxy or [ma.minimum(y),ma.maximum(y)]
685 allylim += ylim
686 stackcount += 1
687 # last in colour stack -> autoscale x
688 if stackcount == nstack:
689 allxlim.sort()
690 self._plotter.axes.set_xlim([allxlim[0],allxlim[-1]])
691 # clear
692 allxlim =[]
693
694 newpanel = False
695 a0=a
696 b0=b
697 # ignore following rows
698 if (panelcount == n) and (stackcount == nstack):
699 # last panel -> autoscale y if ganged
700 if rcParams['plotter.ganged']:
701 allylim.sort()
702 self._plotter.set_limits(ylim=[allylim[0],allylim[-1]])
703 break
704 r+=1 # next row
705 #reset the selector to the scantable's original
706 scan.set_selection(savesel)
707
708 def set_selection(self, selection=None, refresh=True):
709 self._selection = isinstance(selection,selector) and selection or selector()
710 d0 = {'s': 'SCANNO', 'b': 'BEAMNO', 'i':'IFNO',
711 'p': 'POLNO', 'c': 'CYCLENO', 't' : 'TIME' }
712 order = [d0[self._panelling],d0[self._stacking]]
713 self._selection.set_order(order)
714 if self._data and refresh: self.plot(self._data)
715
716 def _get_selected_n(self, scan):
717 d1 = {'b': scan.getbeamnos, 's': scan.getscannos,
718 'i': scan.getifnos, 'p': scan.getpolnos, 't': scan.ncycle }
719 d2 = { 'b': self._selection.get_beams(),
720 's': self._selection.get_scans(),
721 'i': self._selection.get_ifs(),
722 'p': self._selection.get_pols(),
723 't': self._selection.get_cycles() }
724 n = d2[self._panelling] or d1[self._panelling]()
725 nstack = d2[self._stacking] or d1[self._stacking]()
726 return n,nstack
727
728 def _get_label(self, scan, row, mode, userlabel=None):
729 if isinstance(userlabel, list) and len(userlabel) == 0:
730 userlabel = " "
731 pms = dict(zip(self._selection.get_pols(),self._selection.get_poltypes()))
732 if len(pms):
733 poleval = scan._getpollabel(scan.getpol(row),pms[scan.getpol(row)])
734 else:
735 poleval = scan._getpollabel(scan.getpol(row),scan.poltype())
736 d = {'b': "Beam "+str(scan.getbeam(row)),
737 's': scan._getsourcename(row),
738 'i': "IF"+str(scan.getif(row)),
739 'p': poleval,
740 't': str(scan.get_time(row)) }
741 return userlabel or d[mode]
742
Note: See TracBrowser for help on using the repository browser.