source: trunk/python/scantable.py@ 1093

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

removed FITS output, added drop_scan function
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 58.0 KB
Line 
1from asap._asap import Scantable
2from asap import rcParams
3from asap import print_log, asaplog
4from asap import selector
5from numarray import ones,zeros
6import sys
7
8class scantable(Scantable):
9 """
10 The ASAP container for scans
11 """
12
13 def __init__(self, filename, average=None, unit=None):
14 """
15 Create a scantable from a saved one or make a reference
16 Parameters:
17 filename: the name of an asap table on disk
18 or
19 the name of a rpfits/sdfits/ms file
20 (integrations within scans are auto averaged
21 and the whole file is read)
22 or
23 [advanced] a reference to an existing
24 scantable
25 average: average all integrations withinb a scan on read.
26 The default (True) is taken from .asaprc.
27 unit: brightness unit; must be consistent with K or Jy.
28 Over-rides the default selected by the reader
29 (input rpfits/sdfits/ms) or replaces the value
30 in existing scantables
31 """
32 if average is None:
33 average = rcParams['scantable.autoaverage']
34 varlist = vars()
35 from asap._asap import stmath
36 self._math = stmath()
37 if isinstance(filename, Scantable):
38 Scantable.__init__(self, filename)
39 else:
40 if isinstance(filename,str):
41 import os.path
42 filename = os.path.expandvars(filename)
43 filename = os.path.expanduser(filename)
44 if not os.path.exists(filename):
45 s = "File '%s' not found." % (filename)
46 if rcParams['verbose']:
47 asaplog.push(s)
48 print asaplog.pop().strip()
49 return
50 raise IOError(s)
51 if os.path.isdir(filename):
52 # crude check if asap table
53 if os.path.exists(filename+'/table.info'):
54 Scantable.__init__(self, filename, rcParams['scantable.storage']=='disk')
55 if unit is not None:
56 self.set_fluxunit(unit)
57 self.set_freqframe(rcParams['scantable.freqframe'])
58 else:
59 msg = "The given file '%s'is not a valid asap table." % (filename)
60 if rcParams['verbose']:
61 print msg
62 return
63 else:
64 raise IOError(msg)
65 else:
66 self._fill([filename],unit, average)
67 elif (isinstance(filename,list) or isinstance(filename,tuple)) \
68 and isinstance(filename[-1], str):
69 self._fill(filename, unit, average)
70 print_log()
71
72 def save(self, name=None, format=None, overwrite=False):
73 """
74 Store the scantable on disk. This can be an asap (aips++) Table, SDFITS,
75 Image FITS or MS2 format.
76 Parameters:
77 name: the name of the outputfile. For format "ASCII"
78 this is the root file name (data in 'name'.txt
79 and header in 'name'_header.txt)
80 format: an optional file format. Default is ASAP.
81 Allowed are - 'ASAP' (save as ASAP [aips++] Table),
82 'SDFITS' (save as SDFITS file)
83 'ASCII' (saves as ascii text file)
84 'MS2' (saves as an aips++
85 MeasurementSet V2)
86 overwrite: If the file should be overwritten if it exists.
87 The default False is to return with warning
88 without writing the output. USE WITH CARE.
89 Example:
90 scan.save('myscan.asap')
91 scan.save('myscan.sdfits','SDFITS')
92 """
93 from os import path
94 if format is None: format = rcParams['scantable.save']
95 suffix = '.'+format.lower()
96 if name is None or name =="":
97 name = 'scantable'+suffix
98 from asap import asaplog
99 msg = "No filename given. Using default name %s..." % name
100 asaplog.push(msg)
101 name = path.expandvars(name)
102 if path.isfile(name) or path.isdir(name):
103 if not overwrite:
104 msg = "File %s exists." % name
105 if rcParams['verbose']:
106 print msg
107 return
108 else:
109 raise IOError(msg)
110 format2 = format.upper()
111 if format2 == 'ASAP':
112 self._save(name)
113 else:
114 from asap._asap import stwriter as stw
115 w = stw(format2)
116 w.write(self, name)
117 print_log()
118 return
119
120 def copy(self):
121 """
122 Return a copy of this scantable.
123 Parameters:
124 none
125 Example:
126 copiedscan = scan.copy()
127 """
128 sd = scantable(Scantable._copy(self))
129 return sd
130
131 def drop_scan(self, scanid=None):
132 """
133 Return a new scantable where the specified scan number(s) has(have)
134 been dropped.
135 Parameters:
136 scanid: a (list of) scan number(s)
137 """
138 from asap import _is_sequence_or_number as _is_valid
139 from asap import _to_list
140 from asap import unique
141 if not _is_valid(scanid):
142 if rcParams['verbose']:
143 print "Please specify a scanno to drop from the scantable"
144 return
145 else:
146 raise RuntimeError("No scan given")
147 try:
148 scanid = _to_list(scanid)
149 allscans = unique([ self.getscan(i) for i in range(self.nrow())])
150 for sid in scanid: allscans.remove(sid)
151 if len(allscans) == 0: raise ValueError("Can't remove all scans")
152 except ValueError:
153 if rcParams['verbose']:
154 print "Couldn't find any match."
155 return
156 else: raise
157 try:
158 bsel = self.get_selection()
159 sel = selector()
160 sel.set_scans(allscans)
161 self.set_selection(bsel+sel)
162 scopy = self._copy()
163 self.set_selection(bsel)
164 return scantable(scopy)
165 except RuntimeError:
166 if rcParams['verbose']: print "Couldn't find any match."
167 else: raise
168
169
170 def get_scan(self, scanid=None):
171 """
172 Return a specific scan (by scanno) or collection of scans (by
173 source name) in a new scantable.
174 Parameters:
175 scanid: a (list of) scanno or a source name, unix-style
176 patterns are accepted for source name matching, e.g.
177 '*_R' gets all 'ref scans
178 Example:
179 # get all scans containing the source '323p459'
180 newscan = scan.get_scan('323p459')
181 # get all 'off' scans
182 refscans = scan.get_scan('*_R')
183 # get a susbset of scans by scanno (as listed in scan.summary())
184 newscan = scan.get_scan([0,2,7,10])
185 """
186 if scanid is None:
187 if rcParams['verbose']:
188 print "Please specify a scan no or name to retrieve from the scantable"
189 return
190 else:
191 raise RuntimeError("No scan given")
192
193 try:
194 bsel = self.get_selection()
195 sel = selector()
196 if type(scanid) is str:
197 sel.set_name(scanid)
198 self.set_selection(bsel+sel)
199 scopy = self._copy()
200 self.set_selection(bsel)
201 return scantable(scopy)
202 elif type(scanid) is int:
203 sel.set_scans([scanid])
204 self.set_selection(bsel+sel)
205 scopy = self._copy()
206 self.set_selection(bsel)
207 return scantable(scopy)
208 elif type(scanid) is list:
209 sel.set_scans(scanid)
210 self.set_selection(sel)
211 scopy = self._copy()
212 self.set_selection(bsel)
213 return scantable(scopy)
214 else:
215 msg = "Illegal scanid type, use 'int' or 'list' if ints."
216 if rcParams['verbose']:
217 print msg
218 else:
219 raise TypeError(msg)
220 except RuntimeError:
221 if rcParams['verbose']: print "Couldn't find any match."
222 else: raise
223
224 def __str__(self):
225 return Scantable._summary(self,True)
226
227 def summary(self, filename=None):
228 """
229 Print a summary of the contents of this scantable.
230 Parameters:
231 filename: the name of a file to write the putput to
232 Default - no file output
233 verbose: print extra info such as the frequency table
234 The default (False) is taken from .asaprc
235 """
236 info = Scantable._summary(self, True)
237 #if verbose is None: verbose = rcParams['scantable.verbosesummary']
238 if filename is not None:
239 if filename is "":
240 filename = 'scantable_summary.txt'
241 from os.path import expandvars, isdir
242 filename = expandvars(filename)
243 if not isdir(filename):
244 data = open(filename, 'w')
245 data.write(info)
246 data.close()
247 else:
248 msg = "Illegal file name '%s'." % (filename)
249 if rcParams['verbose']:
250 print msg
251 else:
252 raise IOError(msg)
253 if rcParams['verbose']:
254 try:
255 from IPython.genutils import page as pager
256 except ImportError:
257 from pydoc import pager
258 pager(info)
259 else:
260 return info
261
262
263 def get_selection(self):
264 """
265 Get the selection object currently set on this scantable.
266 Parameters:
267 none
268 Example:
269 sel = scan.get_selection()
270 sel.set_ifs(0) # select IF 0
271 scan.set_selection(sel) # apply modified selection
272 """
273 return selector(self._getselection())
274
275 def set_selection(self, selection=selector()):
276 """
277 Select a subset of the data. All following operations on this scantable
278 are only applied to thi selection.
279 Parameters:
280 selection: a selector object (default unset the selection)
281 Examples:
282 sel = selector() # create a selection object
283 self.set_scans([0,3]) # select SCANNO 0 and 3
284 scan.set_selection(sel) # set the selection
285 scan.summary() # will only print summary of scanno 0 an 3
286 scan.set_selection() # unset the selection
287 """
288 self._setselection(selection)
289
290 def set_cursor(self, beam=0, IF=0, pol=0):
291 print "DEPRECATED - use set_selection"
292
293 def get_cursor(self):
294 print "DEPRECATED - use get_selection"
295
296 def stats(self, stat='stddev', mask=None):
297 """
298 Determine the specified statistic of the current beam/if/pol
299 Takes a 'mask' as an optional parameter to specify which
300 channels should be excluded.
301 Parameters:
302 stat: 'min', 'max', 'sumsq', 'sum', 'mean'
303 'var', 'stddev', 'avdev', 'rms', 'median'
304 mask: an optional mask specifying where the statistic
305 should be determined.
306 Example:
307 scan.set_unit('channel')
308 msk = scan.create_mask([100,200],[500,600])
309 scan.stats(stat='mean', mask=m)
310 """
311 from numarray import array,zeros,Float
312 if mask == None:
313 mask = []
314 axes = ['Beam','IF','Pol','Time']
315 if not self._check_ifs():
316 raise ValueError("Cannot apply mask as the IFs have different number of channels"
317 "Please use setselection() to select individual IFs")
318
319 statvals = self._math._stats(self, mask, stat)
320 out = ''
321 axes = []
322 for i in range(self.nrow()):
323 axis = []
324 axis.append(self.getscan(i))
325 axis.append(self.getbeam(i))
326 axis.append(self.getif(i))
327 axis.append(self.getpol(i))
328 axis.append(self.getcycle(i))
329 axes.append(axis)
330 tm = self._gettime(i)
331 src = self._getsourcename(i)
332 out += 'Scan[%d] (%s) ' % (axis[0], src)
333 out += 'Time[%s]:\n' % (tm)
334 if self.nbeam(-1) > 1: out += ' Beam[%d] ' % (axis[1])
335 if self.nif(-1) > 1: out += ' IF[%d] ' % (axis[2])
336 if self.npol(-1) > 1: out += ' Pol[%d] ' % (axis[3])
337 out += '= %3.3f\n' % (statvals[i])
338 out += "--------------------------------------------------\n"
339
340 if rcParams['verbose']:
341 print "--------------------------------------------------"
342 print " ",stat
343 print "--------------------------------------------------"
344 print out
345 retval = { 'axesnames': ['scanno','beamno','ifno','polno','cycleno'],
346 'axes' : axes,
347 'data': statvals}
348 return retval
349
350 def stddev(self,mask=None):
351 """
352 Determine the standard deviation of the current beam/if/pol
353 Takes a 'mask' as an optional parameter to specify which
354 channels should be excluded.
355 Parameters:
356 mask: an optional mask specifying where the standard
357 deviation should be determined.
358
359 Example:
360 scan.set_unit('channel')
361 msk = scan.create_mask([100,200],[500,600])
362 scan.stddev(mask=m)
363 """
364 return self.stats(stat='stddev',mask=mask);
365
366
367 def column_names(self):
368 """
369 Return a list of column names, which can be used for selection.
370 """
371 return list(Scantable.column_names(self))
372
373 def get_tsys(self):
374 """
375 Return the System temperatures.
376 Parameters:
377
378 Returns:
379 a list of Tsys values for the current selection
380 """
381
382 return self._row_callback(self._gettsys, "Tsys")
383
384 def _row_callback(self, callback, label):
385 axes = []
386 axesnames = ['scanno','beamno','ifno','polno','cycleno']
387 out = ""
388 outvec =[]
389 for i in range(self.nrow()):
390 axis = []
391 axis.append(self.getscan(i))
392 axis.append(self.getbeam(i))
393 axis.append(self.getif(i))
394 axis.append(self.getpol(i))
395 axis.append(self.getcycle(i))
396 axes.append(axis)
397 tm = self._gettime(i)
398 src = self._getsourcename(i)
399 out += 'Scan[%d] (%s) ' % (axis[0], src)
400 out += 'Time[%s]:\n' % (tm)
401 if self.nbeam(-1) > 1: out += ' Beam[%d] ' % (axis[1])
402 if self.nif(-1) > 1: out += ' IF[%d] ' % (axis[2])
403 if self.npol(-1) > 1: out += ' Pol[%d] ' % (axis[3])
404 outvec.append(callback(i))
405 out += '= %3.3f\n' % (outvec[i])
406 out += "--------------------------------------------------\n"
407 if rcParams['verbose']:
408 print "--------------------------------------------------"
409 print " %s" % (label)
410 print "--------------------------------------------------"
411 print out
412 retval = {'axesnames': axesnames, 'axes': axes, 'data': outvec}
413 return retval
414
415 def _get_column(self, callback, row=-1):
416 """
417 """
418 if row == -1:
419 return [callback(i) for i in range(self.nrow())]
420 else:
421 if 0 <= row < self.nrow():
422 return callback(row)
423
424
425 def get_time(self, row=-1):
426 """
427 Get a list of time stamps for the observations.
428 Return a string for each integration in the scantable.
429 Parameters:
430 row: row no of integration. Default -1 return all rows
431 Example:
432 none
433 """
434 return self._get_column(self._gettime, row)
435
436 def get_sourcename(self, row=-1):
437 """
438 Get a list source names for the observations.
439 Return a string for each integration in the scantable.
440 Parameters:
441 row: row no of integration. Default -1 return all rows
442 Example:
443 none
444 """
445 return self._get_column(self._getsourcename, row)
446
447 def get_elevation(self, row=-1):
448 """
449 Get a list of elevations for the observations.
450 Return a float for each integration in the scantable.
451 Parameters:
452 row: row no of integration. Default -1 return all rows
453 Example:
454 none
455 """
456 return self._get_column(self._getelevation, row)
457
458 def get_azimuth(self, row=-1):
459 """
460 Get a list of azimuths for the observations.
461 Return a float for each integration in the scantable.
462 Parameters:
463 row: row no of integration. Default -1 return all rows
464 Example:
465 none
466 """
467 return self._get_column(self._getazimuth, row)
468
469 def get_parangle(self, row=-1):
470 """
471 Get a list of parallactic angles for the observations.
472 Return a float for each integration in the scantable.
473 Parameters:
474 row: row no of integration. Default -1 return all rows
475 Example:
476 none
477 """
478 return self._get_column(self._getparangle, row)
479
480 def get_direction(self, row=-1):
481 """
482 Get a list of Positions on the sky (direction) for the observations.
483 Return a float for each integration in the scantable.
484 Parameters:
485 row: row no of integration. Default -1 return all rows
486 Example:
487 none
488 """
489 return self._get_column(self._getdirection, row)
490
491 def set_unit(self, unit='channel'):
492 """
493 Set the unit for all following operations on this scantable
494 Parameters:
495 unit: optional unit, default is 'channel'
496 one of '*Hz','km/s','channel', ''
497 """
498 varlist = vars()
499 if unit in ['','pixel', 'channel']:
500 unit = ''
501 inf = list(self._getcoordinfo())
502 inf[0] = unit
503 self._setcoordinfo(inf)
504 self._add_history("set_unit",varlist)
505
506 def set_instrument(self, instr):
507 """
508 Set the instrument for subsequent processing
509 Parameters:
510 instr: Select from 'ATPKSMB', 'ATPKSHOH', 'ATMOPRA',
511 'DSS-43' (Tid), 'CEDUNA', and 'HOBART'
512 """
513 self._setInstrument(instr)
514 self._add_history("set_instument",vars())
515 print_log()
516
517 def set_doppler(self, doppler='RADIO'):
518 """
519 Set the doppler for all following operations on this scantable.
520 Parameters:
521 doppler: One of 'RADIO', 'OPTICAL', 'Z', 'BETA', 'GAMMA'
522 """
523 varlist = vars()
524 inf = list(self._getcoordinfo())
525 inf[2] = doppler
526 self._setcoordinfo(inf)
527 self._add_history("set_doppler",vars())
528 print_log()
529
530 def set_freqframe(self, frame=None):
531 """
532 Set the frame type of the Spectral Axis.
533 Parameters:
534 frame: an optional frame type, default 'LSRK'. Valid frames are:
535 'REST','TOPO','LSRD','LSRK','BARY',
536 'GEO','GALACTO','LGROUP','CMB'
537 Examples:
538 scan.set_freqframe('BARY')
539 """
540 if frame is None: frame = rcParams['scantable.freqframe']
541 varlist = vars()
542 valid = ['REST','TOPO','LSRD','LSRK','BARY', \
543 'GEO','GALACTO','LGROUP','CMB']
544
545 if frame in valid:
546 inf = list(self._getcoordinfo())
547 inf[1] = frame
548 self._setcoordinfo(inf)
549 self._add_history("set_freqframe",varlist)
550 else:
551 msg = "Please specify a valid freq type. Valid types are:\n",valid
552 if rcParams['verbose']:
553 print msg
554 else:
555 raise TypeError(msg)
556 print_log()
557
558 def set_dirframe(self, frame=""):
559 """
560 Set the frame type of the Direction on the sky.
561 Parameters:
562 frame: an optional frame type, default ''. Valid frames are:
563 'J2000', 'B1950', 'GALACTIC'
564 Examples:
565 scan.set_dirframe('GALACTIC')
566 """
567 varlist = vars()
568 try:
569 Scantable.set_dirframe(self, frame)
570 except RuntimeError,msg:
571 if rcParams['verbose']:
572 print msg
573 else:
574 raise
575 self._add_history("set_dirframe",varlist)
576
577 def get_unit(self):
578 """
579 Get the default unit set in this scantable
580 Parameters:
581 Returns:
582 A unit string
583 """
584 inf = self._getcoordinfo()
585 unit = inf[0]
586 if unit == '': unit = 'channel'
587 return unit
588
589 def get_abcissa(self, rowno=0):
590 """
591 Get the abcissa in the current coordinate setup for the currently
592 selected Beam/IF/Pol
593 Parameters:
594 rowno: an optional row number in the scantable. Default is the
595 first row, i.e. rowno=0
596 Returns:
597 The abcissa values and it's format string (as a dictionary)
598 """
599 abc = self._getabcissa(rowno)
600 lbl = self._getabcissalabel(rowno)
601 print_log()
602 return abc, lbl
603
604 def flag(self, mask=[]):
605 """
606 Flag the selected data using an optional channel mask.
607 Parameters:
608 mask: an optional channel mask, created with create_mask. Default
609 (no mask) is all channels.
610 """
611 varlist = vars()
612 try:
613 self._flag(mask)
614 except RuntimeError,msg:
615 if rcParams['verbose']:
616 print msg
617 return
618 else: raise
619 self._add_history("flag", varlist)
620
621
622 def create_mask(self, *args, **kwargs):
623 """
624 Compute and return a mask based on [min,max] windows.
625 The specified windows are to be INCLUDED, when the mask is
626 applied.
627 Parameters:
628 [min,max],[min2,max2],...
629 Pairs of start/end points (inclusive)specifying the regions
630 to be masked
631 invert: optional argument. If specified as True,
632 return an inverted mask, i.e. the regions
633 specified are EXCLUDED
634 row: create the mask using the specified row for
635 unit conversions, default is row=0
636 only necessary if frequency varies over rows.
637 Example:
638 scan.set_unit('channel')
639 a)
640 msk = scan.create_mask([400,500],[800,900])
641 # masks everything outside 400 and 500
642 # and 800 and 900 in the unit 'channel'
643
644 b)
645 msk = scan.create_mask([400,500],[800,900], invert=True)
646 # masks the regions between 400 and 500
647 # and 800 and 900 in the unit 'channel'
648 c)
649 mask only channel 400
650 msk = scan.create_mask([400,400])
651 """
652 row = 0
653 if kwargs.has_key("row"):
654 row = kwargs.get("row")
655 data = self._getabcissa(row)
656 u = self._getcoordinfo()[0]
657 if rcParams['verbose']:
658 if u == "": u = "channel"
659 from asap import asaplog
660 msg = "The current mask window unit is %s" % u
661 if not self._check_ifs():
662 msg += "\nThis mask is only valid for IF=%d" % (self.getif(i))
663 asaplog.push(msg)
664 n = self.nchan()
665 msk = zeros(n)
666 # test if args is a 'list' or a 'normal *args - UGLY!!!
667
668 ws = (isinstance(args[-1][-1],int) or isinstance(args[-1][-1],float)) and args or args[0]
669 for window in ws:
670 if (len(window) != 2 or window[0] > window[1] ):
671 raise TypeError("A window needs to be defined as [min,max]")
672 for i in range(n):
673 if data[i] >= window[0] and data[i] <= window[1]:
674 msk[i] = 1
675 if kwargs.has_key('invert'):
676 if kwargs.get('invert'):
677 from numarray import logical_not
678 msk = logical_not(msk)
679 print_log()
680 return msk
681
682 def get_restfreqs(self):
683 """
684 Get the restfrequency(s) stored in this scantable.
685 The return value(s) are always of unit 'Hz'
686 Parameters:
687 none
688 Returns:
689 a list of doubles
690 """
691 return list(self._getrestfreqs())
692
693
694 def set_restfreqs(self, freqs=None, unit='Hz'):
695 """
696 Set or replace the restfrequency specified and
697 If the 'freqs' argument holds a scalar,
698 then that rest frequency will be applied to all the selected
699 data. If the 'freqs' argument holds
700 a vector, then it MUST be of equal or smaller length than
701 the number of IFs (and the available restfrequencies will be
702 replaced by this vector). In this case, *all* data have
703 the restfrequency set per IF according
704 to the corresponding value you give in the 'freqs' vector.
705 E.g. 'freqs=[1e9,2e9]' would mean IF 0 gets restfreq 1e9 and
706 IF 1 gets restfreq 2e9.
707 You can also specify the frequencies via known line names
708 from the built-in Lovas table.
709 Parameters:
710 freqs: list of rest frequency values or string idenitfiers
711 unit: unit for rest frequency (default 'Hz')
712
713 Example:
714 # set the given restfrequency for the whole table
715 scan.set_restfreqs(freqs=1.4e9)
716 # If thee number of IFs in the data is >= 2 the IF0 gets the first
717 # value IF1 the second...
718 scan.set_restfreqs(freqs=[1.4e9,1.67e9])
719 #set the given restfrequency for the whole table (by name)
720 scan.set_restfreqs(freqs="OH1667")
721
722 Note:
723 To do more sophisticate Restfrequency setting, e.g. on a
724 source and IF basis, use scantable.set_selection() before using
725 this function.
726 # provide your scantable is call scan
727 selection = selector()
728 selection.set_name("ORION*")
729 selection.set_ifs([1])
730 scan.set_selection(selection)
731 scan.set_restfreqs(freqs=86.6e9)
732
733 """
734 varlist = vars()
735
736 t = type(freqs)
737 if isinstance(freqs, int) or isinstance(freqs,float):
738 self._setrestfreqs(freqs, unit)
739 elif isinstance(freqs, list) or isinstance(freqs,tuple):
740 if isinstance(freqs[-1], int) or isinstance(freqs[-1],float):
741 sel = selector()
742 savesel = self._getselection()
743 for i in xrange(len(freqs)):
744 sel.set_ifs([i])
745 self._setselection(sel)
746 self._setrestfreqs(freqs[i], unit)
747 self._setselection(savesel)
748 elif isinstance(freqs[-1], str):
749 # not yet implemented
750 pass
751 else:
752 return
753 self._add_history("set_restfreqs", varlist)
754
755
756
757 def history(self):
758 hist = list(self._gethistory())
759 out = "-"*80
760 for h in hist:
761 if h.startswith("---"):
762 out += "\n"+h
763 else:
764 items = h.split("##")
765 date = items[0]
766 func = items[1]
767 items = items[2:]
768 out += "\n"+date+"\n"
769 out += "Function: %s\n Parameters:" % (func)
770 for i in items:
771 s = i.split("=")
772 out += "\n %s = %s" % (s[0],s[1])
773 out += "\n"+"-"*80
774 try:
775 from IPython.genutils import page as pager
776 except ImportError:
777 from pydoc import pager
778 pager(out)
779 return
780
781 #
782 # Maths business
783 #
784
785 def average_time(self, mask=None, scanav=False, weight='tint', align=False):
786 """
787 Return the (time) weighted average of a scan.
788 Note:
789 in channels only - align if necessary
790 Parameters:
791 one scan or comma separated scans
792 mask: an optional mask (only used for 'var' and 'tsys'
793 weighting)
794 scanav: True averages each scan separately
795 False (default) averages all scans together,
796 weight: Weighting scheme. 'none', 'var' (1/var(spec)
797 weighted), 'tsys' (1/Tsys**2 weighted), 'tint'
798 (integration time weighted) or 'tintsys' (Tint/Tsys**2).
799 The default is 'tint'
800 align: align the spectra in velocity before averaging. It takes
801 the time of the first spectrum as reference time.
802 Example:
803 # time average the scantable without using a mask
804 newscan = scan.average_time()
805 """
806 varlist = vars()
807 if weight is None: weight = 'TINT'
808 if mask is None: mask = ()
809 if scanav:
810 scanav = "SCAN"
811 else:
812 scanav = "NONE"
813 scan = (self,)
814 try:
815 if align:
816 scan = (self.freq_align(insitu=False),)
817 s = scantable(self._math._average(scan, mask, weight.upper(),
818 scanav))
819 except RuntimeError,msg:
820 if rcParams['verbose']:
821 print msg
822 return
823 else: raise
824 s._add_history("average_time",varlist)
825 print_log()
826 return s
827
828 def average_channel(self, mode="MEDIAN", scanav=False, align=False):
829 """
830 Return the (median) average of a scan.
831 Note:
832 in channels only - align if necessary
833 the median Tsys is computed.
834 Parameters:
835 one scan or comma separated scans
836 mode: type of average, default "MEDIAN"
837 scanav: True averages each scan separately
838 False (default) averages all scans together,
839 align: align the spectra in velocity before averaging. It takes
840 the time of the first spectrum as reference time.
841 Example:
842 # median average the scan
843 newscan = scan.average_channel()
844 """
845 varlist = vars()
846 if mode is None: mode = 'MEDIAN'
847 scanav = "NONE"
848 if scanav: scanav = "SCAN"
849 scan = self
850 try:
851 if align:
852 scan = self.freq_align(insitu=False)
853 s = scantable(self._math._averagechannel(scan, mode, scanav))
854 except RuntimeError,msg:
855 if rcParams['verbose']:
856 print msg
857 return
858 else: raise
859 s._add_history("average_channel",varlist)
860 print_log()
861 return s
862
863 def convert_flux(self, jyperk=None, eta=None, d=None, insitu=None):
864 """
865 Return a scan where all spectra are converted to either
866 Jansky or Kelvin depending upon the flux units of the scan table.
867 By default the function tries to look the values up internally.
868 If it can't find them (or if you want to over-ride), you must
869 specify EITHER jyperk OR eta (and D which it will try to look up
870 also if you don't set it). jyperk takes precedence if you set both.
871 Parameters:
872 jyperk: the Jy / K conversion factor
873 eta: the aperture efficiency
874 d: the geomtric diameter (metres)
875 insitu: if False a new scantable is returned.
876 Otherwise, the scaling is done in-situ
877 The default is taken from .asaprc (False)
878 allaxes: if True apply to all spectra. Otherwise
879 apply only to the selected (beam/pol/if)spectra only
880 The default is taken from .asaprc (True if none)
881 """
882 if insitu is None: insitu = rcParams['insitu']
883 self._math._setinsitu(insitu)
884 varlist = vars()
885 if jyperk is None: jyperk = -1.0
886 if d is None: d = -1.0
887 if eta is None: eta = -1.0
888 s = scantable(self._math._convertflux(self, d, eta, jyperk))
889 s._add_history("convert_flux", varlist)
890 print_log()
891 if insitu: self._assign(s)
892 else: return s
893
894 def gain_el(self, poly=None, filename="", method="linear", insitu=None):
895 """
896 Return a scan after applying a gain-elevation correction.
897 The correction can be made via either a polynomial or a
898 table-based interpolation (and extrapolation if necessary).
899 You specify polynomial coefficients, an ascii table or neither.
900 If you specify neither, then a polynomial correction will be made
901 with built in coefficients known for certain telescopes (an error
902 will occur if the instrument is not known).
903 The data and Tsys are *divided* by the scaling factors.
904 Parameters:
905 poly: Polynomial coefficients (default None) to compute a
906 gain-elevation correction as a function of
907 elevation (in degrees).
908 filename: The name of an ascii file holding correction factors.
909 The first row of the ascii file must give the column
910 names and these MUST include columns
911 "ELEVATION" (degrees) and "FACTOR" (multiply data
912 by this) somewhere.
913 The second row must give the data type of the
914 column. Use 'R' for Real and 'I' for Integer.
915 An example file would be
916 (actual factors are arbitrary) :
917
918 TIME ELEVATION FACTOR
919 R R R
920 0.1 0 0.8
921 0.2 20 0.85
922 0.3 40 0.9
923 0.4 60 0.85
924 0.5 80 0.8
925 0.6 90 0.75
926 method: Interpolation method when correcting from a table.
927 Values are "nearest", "linear" (default), "cubic"
928 and "spline"
929 insitu: if False a new scantable is returned.
930 Otherwise, the scaling is done in-situ
931 The default is taken from .asaprc (False)
932 """
933
934 if insitu is None: insitu = rcParams['insitu']
935 self._math._setinsitu(insitu)
936 varlist = vars()
937 if poly is None:
938 poly = ()
939 from os.path import expandvars
940 filename = expandvars(filename)
941 s = scantable(self._math._gainel(self, poly, filename, method))
942 s._add_history("gain_el", varlist)
943 print_log()
944 if insitu: self._assign(s)
945 else: return s
946
947 def freq_align(self, reftime=None, method='cubic', insitu=None):
948 """
949 Return a scan where all rows have been aligned in frequency/velocity.
950 The alignment frequency frame (e.g. LSRK) is that set by function
951 set_freqframe.
952 Parameters:
953 reftime: reference time to align at. By default, the time of
954 the first row of data is used.
955 method: Interpolation method for regridding the spectra.
956 Choose from "nearest", "linear", "cubic" (default)
957 and "spline"
958 insitu: if False a new scantable is returned.
959 Otherwise, the scaling is done in-situ
960 The default is taken from .asaprc (False)
961 """
962 if insitu is None: insitu = rcParams["insitu"]
963 self._math._setinsitu(insitu)
964 varlist = vars()
965 if reftime is None: reftime = ""
966 s = scantable(self._math._freq_align(self, reftime, method))
967 s._add_history("freq_align", varlist)
968 print_log()
969 if insitu: self._assign(s)
970 else: return s
971
972 def opacity(self, tau, insitu=None):
973 """
974 Apply an opacity correction. The data
975 and Tsys are multiplied by the correction factor.
976 Parameters:
977 tau: Opacity from which the correction factor is
978 exp(tau*ZD)
979 where ZD is the zenith-distance
980 insitu: if False a new scantable is returned.
981 Otherwise, the scaling is done in-situ
982 The default is taken from .asaprc (False)
983 """
984 if insitu is None: insitu = rcParams['insitu']
985 self._math._setinsitu(insitu)
986 varlist = vars()
987 s = scantable(self._math._opacity(self, tau))
988 s._add_history("opacity", varlist)
989 print_log()
990 if insitu: self._assign(s)
991 else: return s
992
993 def bin(self, width=5, insitu=None):
994 """
995 Return a scan where all spectra have been binned up.
996 width: The bin width (default=5) in pixels
997 insitu: if False a new scantable is returned.
998 Otherwise, the scaling is done in-situ
999 The default is taken from .asaprc (False)
1000 """
1001 if insitu is None: insitu = rcParams['insitu']
1002 self._math._setinsitu(insitu)
1003 varlist = vars()
1004 s = scantable(self._math._bin(self, width))
1005 s._add_history("bin",varlist)
1006 print_log()
1007 if insitu: self._assign(s)
1008 else: return s
1009
1010
1011 def resample(self, width=5, method='cubic', insitu=None):
1012 """
1013 Return a scan where all spectra have been binned up
1014 width: The bin width (default=5) in pixels
1015 method: Interpolation method when correcting from a table.
1016 Values are "nearest", "linear", "cubic" (default)
1017 and "spline"
1018 insitu: if False a new scantable is returned.
1019 Otherwise, the scaling is done in-situ
1020 The default is taken from .asaprc (False)
1021 """
1022 if insitu is None: insitu = rcParams['insitu']
1023 self._math._setinsitu(insitu)
1024 varlist = vars()
1025 s = scantable(self._math._resample(self, method, width))
1026 s._add_history("resample",varlist)
1027 print_log()
1028 if insitu: self._assign(s)
1029 else: return s
1030
1031
1032 def average_pol(self, mask=None, weight='none'):
1033 """
1034 Average the Polarisations together.
1035 Parameters:
1036 mask: An optional mask defining the region, where the
1037 averaging will be applied. The output will have all
1038 specified points masked.
1039 weight: Weighting scheme. 'none' (default), 'var' (1/var(spec)
1040 weighted), or 'tsys' (1/Tsys**2 weighted)
1041 """
1042 varlist = vars()
1043 if mask is None:
1044 mask = ()
1045 s = scantable(self._math._averagepol(self, mask, weight.upper()))
1046 s._add_history("average_pol",varlist)
1047 print_log()
1048 return s
1049
1050 def convert_pol(self, poltype=None):
1051 """
1052 Convert the data to a different polarisation type.
1053 Parameters:
1054 poltype: The new polarisation type. Valid types are:
1055 "linear", "stokes" and "circular"
1056 """
1057 varlist = vars()
1058 try:
1059 s = scantable(self._math._convertpol(self, poltype))
1060 except RuntimeError,msg:
1061 if rcParams['verbose']:
1062 print msg
1063 return
1064 else:
1065 raise
1066 s._add_history("convert_pol",varlist)
1067 print_log()
1068 return s
1069
1070 def smooth(self, kernel="hanning", width=5.0, insitu=None):
1071 """
1072 Smooth the spectrum by the specified kernel (conserving flux).
1073 Parameters:
1074 scan: The input scan
1075 kernel: The type of smoothing kernel. Select from
1076 'hanning' (default), 'gaussian' and 'boxcar'.
1077 The first three characters are sufficient.
1078 width: The width of the kernel in pixels. For hanning this is
1079 ignored otherwise it defauls to 5 pixels.
1080 For 'gaussian' it is the Full Width Half
1081 Maximum. For 'boxcar' it is the full width.
1082 insitu: if False a new scantable is returned.
1083 Otherwise, the scaling is done in-situ
1084 The default is taken from .asaprc (False)
1085 Example:
1086 none
1087 """
1088 if insitu is None: insitu = rcParams['insitu']
1089 self._math._setinsitu(insitu)
1090 varlist = vars()
1091 s = scantable(self._math._smooth(self,kernel.lower(),width))
1092 s._add_history("smooth", varlist)
1093 print_log()
1094 if insitu: self._assign(s)
1095 else: return s
1096
1097
1098 def poly_baseline(self, mask=None, order=0, plot=False, insitu=None):
1099 """
1100 Return a scan which has been baselined (all rows) by a polynomial.
1101 Parameters:
1102 scan: a scantable
1103 mask: an optional mask
1104 order: the order of the polynomial (default is 0)
1105 plot: plot the fit and the residual. In this each
1106 indivual fit has to be approved, by typing 'y'
1107 or 'n'
1108 insitu: if False a new scantable is returned.
1109 Otherwise, the scaling is done in-situ
1110 The default is taken from .asaprc (False)
1111 Example:
1112 # return a scan baselined by a third order polynomial,
1113 # not using a mask
1114 bscan = scan.poly_baseline(order=3)
1115 """
1116 if insitu is None: insitu = rcParams['insitu']
1117 varlist = vars()
1118 if mask is None:
1119 from numarray import ones
1120 mask = list(ones(self.nchan(-1)))
1121 from asap.asapfitter import fitter
1122 f = fitter()
1123 f.set_scan(self, mask)
1124 f.set_function(poly=order)
1125 s = f.auto_fit(insitu, plot=plot)
1126 s._add_history("poly_baseline", varlist)
1127 print_log()
1128 if insitu: self._assign(s)
1129 else: return s
1130
1131 def auto_poly_baseline(self, mask=[], edge=(0,0), order=0,
1132 threshold=3, plot=False, insitu=None):
1133 """
1134 Return a scan which has been baselined (all rows) by a polynomial.
1135 Spectral lines are detected first using linefinder and masked out
1136 to avoid them affecting the baseline solution.
1137
1138 Parameters:
1139 mask: an optional mask retreived from scantable
1140 edge: an optional number of channel to drop at
1141 the edge of spectrum. If only one value is
1142 specified, the same number will be dropped from
1143 both sides of the spectrum. Default is to keep
1144 all channels. Nested tuples represent individual
1145 edge selection for different IFs (a number of spectral
1146 channels can be different)
1147 order: the order of the polynomial (default is 0)
1148 threshold: the threshold used by line finder. It is better to
1149 keep it large as only strong lines affect the
1150 baseline solution.
1151 plot: plot the fit and the residual. In this each
1152 indivual fit has to be approved, by typing 'y'
1153 or 'n'
1154 insitu: if False a new scantable is returned.
1155 Otherwise, the scaling is done in-situ
1156 The default is taken from .asaprc (False)
1157
1158 Example:
1159 scan2=scan.auto_poly_baseline(order=7)
1160 """
1161 if insitu is None: insitu = rcParams['insitu']
1162 varlist = vars()
1163 from asap.asapfitter import fitter
1164 from asap.asaplinefind import linefinder
1165 from asap import _is_sequence_or_number as _is_valid
1166
1167 # check whether edge is set up for each IF individually
1168 individualEdge = False;
1169 if len(edge)>1:
1170 if isinstance(edge[0],list) or isinstance(edge[0],tuple):
1171 individualEdge = True;
1172
1173 if not _is_valid(edge, int) and not individualEdge:
1174 raise ValueError, "Parameter 'edge' has to be an integer or a \
1175 pair of integers specified as a tuple. Nested tuples are allowed \
1176 to make individual selection for different IFs."
1177
1178 curedge = (0,0)
1179 if individualEdge:
1180 for edge_par in edge:
1181 if not _is_valid(edge,int):
1182 raise ValueError, "Each element of the 'edge' tuple has \
1183 to be a pair of integers or an integer."
1184 else:
1185 curedge = edge;
1186
1187 # setup fitter
1188 f = fitter()
1189 f.set_function(poly=order)
1190
1191 # setup line finder
1192 fl=linefinder()
1193 fl.set_options(threshold=threshold)
1194
1195 if not insitu:
1196 workscan=self.copy()
1197 else:
1198 workscan=self
1199
1200 fl.set_scan(workscan)
1201
1202 rows=range(workscan.nrow())
1203 from asap import asaplog
1204 asaplog.push("Processing:")
1205 for r in rows:
1206 msg = " Scan[%d] Beam[%d] IF[%d] Pol[%d] Cycle[%d]" % (workscan.getscan(r),workscan.getbeam(r),workscan.getif(r),workscan.getpol(r), workscan.getcycle(r))
1207 asaplog.push(msg, False)
1208
1209 # figure out edge parameter
1210 if individualEdge:
1211 if len(edge)>=workscan.getif(r):
1212 raise RuntimeError, "Number of edge elements appear to be less than the number of IFs"
1213 curedge = edge[workscan.getif(r)]
1214
1215 # setup line finder
1216 fl.find_lines(r,mask,curedge)
1217 f.set_scan(workscan, fl.get_mask())
1218 f.x = workscan._getabcissa(r)
1219 f.y = workscan._getspectrum(r)
1220 f.data = None
1221 f.fit()
1222 x = f.get_parameters()
1223 if plot:
1224 f.plot(residual=True)
1225 x = raw_input("Accept fit ( [y]/n ): ")
1226 if x.upper() == 'N':
1227 continue
1228 workscan._setspectrum(f.fitter.getresidual(), r)
1229 if plot:
1230 f._p.unmap()
1231 f._p = None
1232 workscan._add_history("auto_poly_baseline", varlist)
1233 if insitu:
1234 self._assign(workscan)
1235 else:
1236 return workscan
1237
1238 def rotate_linpolphase(self, angle):
1239 """
1240 Rotate the phase of the complex polarization O=Q+iU correlation.
1241 This is always done in situ in the raw data. So if you call this
1242 function more than once then each call rotates the phase further.
1243 Parameters:
1244 angle: The angle (degrees) to rotate (add) by.
1245 Examples:
1246 scan.rotate_linpolphase(2.3)
1247 """
1248 varlist = vars()
1249 self._math._rotate_linpolphase(self, angle)
1250 self._add_history("rotate_linpolphase", varlist)
1251 print_log()
1252 return
1253
1254
1255 def rotate_xyphase(self, angle):
1256 """
1257 Rotate the phase of the XY correlation. This is always done in situ
1258 in the data. So if you call this function more than once
1259 then each call rotates the phase further.
1260 Parameters:
1261 angle: The angle (degrees) to rotate (add) by.
1262 Examples:
1263 scan.rotate_xyphase(2.3)
1264 """
1265 varlist = vars()
1266 self._math._rotate_xyphase(self, angle)
1267 self._add_history("rotate_xyphase", varlist)
1268 print_log()
1269 return
1270
1271 def swap_linears(self):
1272 """
1273 Swap the linear polarisations XX and YY
1274 """
1275 varlist = vars()
1276 self._math._swap_linears(self)
1277 self._add_history("swap_linears", varlist)
1278 print_log()
1279 return
1280
1281 def invert_phase(self):
1282 """
1283 Invert the phase of the complex polarisation
1284 """
1285 varlist = vars()
1286 self._math._invert_phase(self)
1287 self._add_history("invert_phase", varlist)
1288 print_log()
1289 return
1290
1291 def add(self, offset, insitu=None):
1292 """
1293 Return a scan where all spectra have the offset added
1294 Parameters:
1295 offset: the offset
1296 insitu: if False a new scantable is returned.
1297 Otherwise, the scaling is done in-situ
1298 The default is taken from .asaprc (False)
1299 """
1300 if insitu is None: insitu = rcParams['insitu']
1301 self._math._setinsitu(insitu)
1302 varlist = vars()
1303 s = scantable(self._math._unaryop(self, offset, "ADD", False))
1304 s._add_history("add",varlist)
1305 print_log()
1306 if insitu:
1307 self._assign(s)
1308 else:
1309 return s
1310
1311 def scale(self, factor, tsys=True, insitu=None,):
1312 """
1313 Return a scan where all spectra are scaled by the give 'factor'
1314 Parameters:
1315 factor: the scaling factor
1316 insitu: if False a new scantable is returned.
1317 Otherwise, the scaling is done in-situ
1318 The default is taken from .asaprc (False)
1319 tsys: if True (default) then apply the operation to Tsys
1320 as well as the data
1321 """
1322 if insitu is None: insitu = rcParams['insitu']
1323 self._math._setinsitu(insitu)
1324 varlist = vars()
1325 s = scantable(self._math._unaryop(self, factor, "MUL", tsys))
1326 s._add_history("scale",varlist)
1327 print_log()
1328 if insitu:
1329 self._assign(s)
1330 else:
1331 return s
1332
1333 def auto_quotient(self, mode='time', preserve=True):
1334 """
1335 This function allows to build quotients automatically.
1336 It assumes the observation to have the same numer of
1337 "ons" and "offs"
1338 It will support "closest off in time" in the future
1339 Parameters:
1340 mode: the on/off detection mode; 'suffix' (default)
1341 'suffix' identifies 'off' scans by the
1342 trailing '_R' (Mopra/Parkes) or
1343 '_e'/'_w' (Tid)
1344 preserve: you can preserve (default) the continuum or
1345 remove it. The equations used are
1346 preserve: Output = Toff * (on/off) - Toff
1347 remove: Output = Toff * (on/off) - Ton
1348 """
1349 modes = ["time"]
1350 if not mode in modes:
1351 msg = "please provide valid mode. Valid modes are %s" % (modes)
1352 raise ValueError(msg)
1353 varlist = vars()
1354 s = scantable(self._math._auto_quotient(self, mode, preserve))
1355 s._add_history("auto_quotient",varlist)
1356 print_log()
1357 return s
1358
1359
1360
1361
1362 def freq_switch(self, insitu=None):
1363 """
1364 Apply frequency switching to the data.
1365 Parameters:
1366 insitu: if False a new scantable is returned.
1367 Otherwise, the swictching is done in-situ
1368 The default is taken from .asaprc (False)
1369 Example:
1370 none
1371 """
1372 if insitu is None: insitu = rcParams['insitu']
1373 self._math._setinsitu(insitu)
1374 varlist = vars()
1375 s = scantable(self._math._freqswitch(self))
1376 s._add_history("freq_switch",varlist)
1377 print_log()
1378 if insitu: self._assign(s)
1379 else: return s
1380
1381 def recalc_azel(self):
1382 """
1383 Recalculate the azimuth and elevation for each position.
1384 Parameters:
1385 none
1386 Example:
1387 """
1388 varlist = vars()
1389 self._recalcazel()
1390 self._add_history("recalc_azel", varlist)
1391 print_log()
1392 return
1393
1394 def __add__(self, other):
1395 varlist = vars()
1396 s = None
1397 if isinstance(other, scantable):
1398 print "scantable + scantable NYI"
1399 return
1400 elif isinstance(other, float):
1401 s = scantable(self._math._unaryop(self, other, "ADD", False))
1402 else:
1403 raise TypeError("Other input is not a scantable or float value")
1404 s._add_history("operator +", varlist)
1405 print_log()
1406 return s
1407
1408 def __sub__(self, other):
1409 """
1410 implicit on all axes and on Tsys
1411 """
1412 varlist = vars()
1413 s = None
1414 if isinstance(other, scantable):
1415 print "scantable - scantable NYI"
1416 return
1417 elif isinstance(other, float):
1418 s = scantable(self._math._unaryop(self, other, "SUB", False))
1419 else:
1420 raise TypeError("Other input is not a scantable or float value")
1421 s._add_history("operator -", varlist)
1422 print_log()
1423 return s
1424
1425 def __mul__(self, other):
1426 """
1427 implicit on all axes and on Tsys
1428 """
1429 varlist = vars()
1430 s = None
1431 if isinstance(other, scantable):
1432 print "scantable * scantable NYI"
1433 return
1434 elif isinstance(other, float):
1435 s = scantable(self._math._unaryop(self, other, "MUL", False))
1436 else:
1437 raise TypeError("Other input is not a scantable or float value")
1438 s._add_history("operator *", varlist)
1439 print_log()
1440 return s
1441
1442
1443 def __div__(self, other):
1444 """
1445 implicit on all axes and on Tsys
1446 """
1447 varlist = vars()
1448 s = None
1449 if isinstance(other, scantable):
1450 print "scantable / scantable NYI"
1451 return
1452 elif isinstance(other, float):
1453 if other == 0.0:
1454 raise ZeroDivisionError("Dividing by zero is not recommended")
1455 s = scantable(self._math._unaryop(self, other, "DIV", False))
1456 else:
1457 raise TypeError("Other input is not a scantable or float value")
1458 s._add_history("operator /", varlist)
1459 print_log()
1460 return s
1461
1462 def get_fit(self, row=0):
1463 """
1464 Print or return the stored fits for a row in the scantable
1465 Parameters:
1466 row: the row which the fit has been applied to.
1467 """
1468 if row > self.nrow():
1469 return
1470 from asap.asapfit import asapfit
1471 fit = asapfit(self._getfit(row))
1472 if rcParams['verbose']:
1473 print fit
1474 return
1475 else:
1476 return fit.as_dict()
1477
1478 def _add_history(self, funcname, parameters):
1479 # create date
1480 sep = "##"
1481 from datetime import datetime
1482 dstr = datetime.now().strftime('%Y/%m/%d %H:%M:%S')
1483 hist = dstr+sep
1484 hist += funcname+sep#cdate+sep
1485 if parameters.has_key('self'): del parameters['self']
1486 for k,v in parameters.iteritems():
1487 if type(v) is dict:
1488 for k2,v2 in v.iteritems():
1489 hist += k2
1490 hist += "="
1491 if isinstance(v2,scantable):
1492 hist += 'scantable'
1493 elif k2 == 'mask':
1494 if isinstance(v2,list) or isinstance(v2,tuple):
1495 hist += str(self._zip_mask(v2))
1496 else:
1497 hist += str(v2)
1498 else:
1499 hist += str(v2)
1500 else:
1501 hist += k
1502 hist += "="
1503 if isinstance(v,scantable):
1504 hist += 'scantable'
1505 elif k == 'mask':
1506 if isinstance(v,list) or isinstance(v,tuple):
1507 hist += str(self._zip_mask(v))
1508 else:
1509 hist += str(v)
1510 else:
1511 hist += str(v)
1512 hist += sep
1513 hist = hist[:-2] # remove trailing '##'
1514 self._addhistory(hist)
1515
1516
1517 def _zip_mask(self, mask):
1518 mask = list(mask)
1519 i = 0
1520 segments = []
1521 while mask[i:].count(1):
1522 i += mask[i:].index(1)
1523 if mask[i:].count(0):
1524 j = i + mask[i:].index(0)
1525 else:
1526 j = len(mask)
1527 segments.append([i,j])
1528 i = j
1529 return segments
1530
1531 def _get_ordinate_label(self):
1532 fu = "("+self.get_fluxunit()+")"
1533 import re
1534 lbl = "Intensity"
1535 if re.match(".K.",fu):
1536 lbl = "Brightness Temperature "+ fu
1537 elif re.match(".Jy.",fu):
1538 lbl = "Flux density "+ fu
1539 return lbl
1540
1541 def _check_ifs(self):
1542 nchans = [self.nchan(i) for i in range(self.nif(-1))]
1543 nchans = filter(lambda t: t > 0, nchans)
1544 return (sum(nchans)/len(nchans) == nchans[0])
1545
1546 def _fill(self, names, unit, average):
1547 import os
1548 varlist = vars()
1549 from asap._asap import stfiller
1550 first = True
1551 fullnames = []
1552 for name in names:
1553 name = os.path.expandvars(name)
1554 name = os.path.expanduser(name)
1555 if not os.path.exists(name):
1556 msg = "File '%s' does not exists" % (name)
1557 if rcParams['verbose']:
1558 asaplog.push(msg)
1559 print asaplog.pop().strip()
1560 return
1561 raise IOError(msg)
1562 fullnames.append(name)
1563 if average:
1564 asaplog.push('Auto averaging integrations')
1565 stype = int(rcParams['scantable.storage'].lower() == 'disk')
1566 for name in fullnames:
1567 tbl = Scantable(stype)
1568 r = stfiller(tbl)
1569 msg = "Importing %s..." % (name)
1570 asaplog.push(msg,False)
1571 print_log()
1572 r._open(name,-1,-1)
1573 r._read()
1574 #tbl = r._getdata()
1575 if average:
1576 tbl = self._math._average((tbl,),(),'NONE','SCAN')
1577 #tbl = tbl2
1578 if not first:
1579 tbl = self._math._merge([self, tbl])
1580 #tbl = tbl2
1581 Scantable.__init__(self, tbl)
1582 r._close()
1583 del r,tbl
1584 first = False
1585 if unit is not None:
1586 self.set_fluxunit(unit)
1587 self.set_freqframe(rcParams['scantable.freqframe'])
1588 #self._add_history("scantable", varlist)
1589
Note: See TracBrowser for help on using the repository browser.