source: branches/alma/python/scantable.py@ 1652

Last change on this file since 1652 was 1649, checked in by TakTsutsumi, 15 years ago

New Development: No

JIRA Issue: No (regression test failure)

Ready to Release: Yes

Interface Changes: No

What Interface Changed: Please list interface changes

Test Programs: List test programs

Put in Release Notes: No

Module(s): Module Names change impacts.

Description: fixed a bug in scantable.poly_baseline()


  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 82.9 KB
Line 
1from asap._asap import Scantable
2from asap import rcParams
3from asap import print_log
4from asap import asaplog
5from asap import selector
6from asap import linecatalog
7from asap import _n_bools, mask_not, mask_and, mask_or
8
9class scantable(Scantable):
10 """
11 The ASAP container for scans
12 """
13
14 def __init__(self, filename, average=None, unit=None, getpt=None):
15 """
16 Create a scantable from a saved one or make a reference
17 Parameters:
18 filename: the name of an asap table on disk
19 or
20 the name of a rpfits/sdfits/ms file
21 (integrations within scans are auto averaged
22 and the whole file is read)
23 or
24 [advanced] a reference to an existing
25 scantable
26 average: average all integrations withinb a scan on read.
27 The default (True) is taken from .asaprc.
28 unit: brightness unit; must be consistent with K or Jy.
29 Over-rides the default selected by the reader
30 (input rpfits/sdfits/ms) or replaces the value
31 in existing scantables
32 getpt: for MeasurementSet input data only:
33 If True, all pointing data are filled.
34 The deafult is False, which makes time to load
35 the MS data faster in some cases.
36 """
37 if average is None:
38 average = rcParams['scantable.autoaverage']
39 if getpt is None:
40 getpt = False
41 varlist = vars()
42 from asap._asap import stmath
43 self._math = stmath()
44 if isinstance(filename, Scantable):
45 Scantable.__init__(self, filename)
46 else:
47 if isinstance(filename, str):# or \
48# (isinstance(filename, list) or isinstance(filename, tuple)) \
49# and isinstance(filename[-1], str):
50 import os.path
51 filename = os.path.expandvars(filename)
52 filename = os.path.expanduser(filename)
53 if not os.path.exists(filename):
54 s = "File '%s' not found." % (filename)
55 if rcParams['verbose']:
56 asaplog.push(s)
57 #print asaplog.pop().strip()
58 print_log('ERROR')
59 return
60 raise IOError(s)
61 if os.path.isdir(filename) \
62 and not os.path.exists(filename+'/table.f1'):
63 # crude check if asap table
64 if os.path.exists(filename+'/table.info'):
65 ondisk = rcParams['scantable.storage'] == 'disk'
66 Scantable.__init__(self, filename, ondisk)
67 if unit is not None:
68 self.set_fluxunit(unit)
69 # do not reset to the default freqframe
70 #self.set_freqframe(rcParams['scantable.freqframe'])
71 else:
72 msg = "The given file '%s'is not a valid " \
73 "asap table." % (filename)
74 if rcParams['verbose']:
75 #print msg
76 asaplog.push( msg )
77 print_log( 'ERROR' )
78 return
79 else:
80 raise IOError(msg)
81 else:
82 self._fill([filename], unit, average, getpt)
83 elif (isinstance(filename, list) or isinstance(filename, tuple)) \
84 and isinstance(filename[-1], str):
85 self._fill(filename, unit, average, getpt)
86 self._add_history("scantable", varlist)
87 print_log()
88
89 def save(self, name=None, format=None, overwrite=False):
90 """
91 Store the scantable on disk. This can be an asap (aips++) Table,
92 SDFITS or MS2 format.
93 Parameters:
94 name: the name of the outputfile. For format "ASCII"
95 this is the root file name (data in 'name'.txt
96 and header in 'name'_header.txt)
97 format: an optional file format. Default is ASAP.
98 Allowed are - 'ASAP' (save as ASAP [aips++] Table),
99 'SDFITS' (save as SDFITS file)
100 'ASCII' (saves as ascii text file)
101 'MS2' (saves as an aips++
102 MeasurementSet V2)
103 'FITS' (save as image FITS - not
104 readable by class)
105 'CLASS' (save as FITS readable by CLASS)
106 overwrite: If the file should be overwritten if it exists.
107 The default False is to return with warning
108 without writing the output. USE WITH CARE.
109 Example:
110 scan.save('myscan.asap')
111 scan.save('myscan.sdfits', 'SDFITS')
112 """
113 from os import path
114 if format is None: format = rcParams['scantable.save']
115 suffix = '.'+format.lower()
116 if name is None or name == "":
117 name = 'scantable'+suffix
118 msg = "No filename given. Using default name %s..." % name
119 asaplog.push(msg)
120 name = path.expandvars(name)
121 if path.isfile(name) or path.isdir(name):
122 if not overwrite:
123 msg = "File %s exists." % name
124 if rcParams['verbose']:
125 #print msg
126 asaplog.push( msg )
127 print_log( 'ERROR' )
128 return
129 else:
130 raise IOError(msg)
131 format2 = format.upper()
132 if format2 == 'ASAP':
133 self._save(name)
134 else:
135 from asap._asap import stwriter as stw
136 writer = stw(format2)
137 writer.write(self, name)
138 print_log()
139 return
140
141 def copy(self):
142 """
143 Return a copy of this scantable.
144 Note:
145 This makes a full (deep) copy. scan2 = scan1 makes a reference.
146 Parameters:
147 none
148 Example:
149 copiedscan = scan.copy()
150 """
151 sd = scantable(Scantable._copy(self))
152 return sd
153
154 def drop_scan(self, scanid=None):
155 """
156 Return a new scantable where the specified scan number(s) has(have)
157 been dropped.
158 Parameters:
159 scanid: a (list of) scan number(s)
160 """
161 from asap import _is_sequence_or_number as _is_valid
162 from asap import _to_list
163 from asap import unique
164 if not _is_valid(scanid):
165 if rcParams['verbose']:
166 #print "Please specify a scanno to drop from the scantable"
167 asaplog.push( 'Please specify a scanno to drop from the scantable' )
168 print_log( 'ERROR' )
169 return
170 else:
171 raise RuntimeError("No scan given")
172 try:
173 scanid = _to_list(scanid)
174 allscans = unique([ self.getscan(i) for i in range(self.nrow())])
175 for sid in scanid: allscans.remove(sid)
176 if len(allscans) == 0:
177 raise ValueError("Can't remove all scans")
178 except ValueError:
179 if rcParams['verbose']:
180 #print "Couldn't find any match."
181 print_log()
182 asaplog.push( "Couldn't find any match." )
183 print_log( 'ERROR' )
184 return
185 else: raise
186 try:
187 bsel = self.get_selection()
188 sel = selector()
189 sel.set_scans(allscans)
190 self.set_selection(bsel+sel)
191 scopy = self._copy()
192 self.set_selection(bsel)
193 return scantable(scopy)
194 except RuntimeError:
195 if rcParams['verbose']:
196 #print "Couldn't find any match."
197 print_log()
198 asaplog.push( "Couldn't find any match." )
199 print_log( 'ERROR' )
200 else:
201 raise
202
203
204 def get_scan(self, scanid=None):
205 """
206 Return a specific scan (by scanno) or collection of scans (by
207 source name) in a new scantable.
208 Note:
209 See scantable.drop_scan() for the inverse operation.
210 Parameters:
211 scanid: a (list of) scanno or a source name, unix-style
212 patterns are accepted for source name matching, e.g.
213 '*_R' gets all 'ref scans
214 Example:
215 # get all scans containing the source '323p459'
216 newscan = scan.get_scan('323p459')
217 # get all 'off' scans
218 refscans = scan.get_scan('*_R')
219 # get a susbset of scans by scanno (as listed in scan.summary())
220 newscan = scan.get_scan([0, 2, 7, 10])
221 """
222 if scanid is None:
223 if rcParams['verbose']:
224 #print "Please specify a scan no or name to " \
225 # "retrieve from the scantable"
226 asaplog.push( 'Please specify a scan no or name to retrieve from the scantable' )
227 print_log( 'ERROR' )
228 return
229 else:
230 raise RuntimeError("No scan given")
231
232 try:
233 bsel = self.get_selection()
234 sel = selector()
235 if type(scanid) is str:
236 sel.set_name(scanid)
237 self.set_selection(bsel+sel)
238 scopy = self._copy()
239 self.set_selection(bsel)
240 return scantable(scopy)
241 elif type(scanid) is int:
242 sel.set_scans([scanid])
243 self.set_selection(bsel+sel)
244 scopy = self._copy()
245 self.set_selection(bsel)
246 return scantable(scopy)
247 elif type(scanid) is list:
248 sel.set_scans(scanid)
249 self.set_selection(sel)
250 scopy = self._copy()
251 self.set_selection(bsel)
252 return scantable(scopy)
253 else:
254 msg = "Illegal scanid type, use 'int' or 'list' if ints."
255 if rcParams['verbose']:
256 #print msg
257 asaplog.push( msg )
258 print_log( 'ERROR' )
259 else:
260 raise TypeError(msg)
261 except RuntimeError:
262 if rcParams['verbose']:
263 #print "Couldn't find any match."
264 print_log()
265 asaplog.push( "Couldn't find any match." )
266 print_log( 'ERROR' )
267 else: raise
268
269 def __str__(self):
270 return Scantable._summary(self, True)
271
272 def summary(self, filename=None):
273 """
274 Print a summary of the contents of this scantable.
275 Parameters:
276 filename: the name of a file to write the putput to
277 Default - no file output
278 verbose: print extra info such as the frequency table
279 The default (False) is taken from .asaprc
280 """
281 info = Scantable._summary(self, True)
282 #if verbose is None: verbose = rcParams['scantable.verbosesummary']
283 if filename is not None:
284 if filename is "":
285 filename = 'scantable_summary.txt'
286 from os.path import expandvars, isdir
287 filename = expandvars(filename)
288 if not isdir(filename):
289 data = open(filename, 'w')
290 data.write(info)
291 data.close()
292 else:
293 msg = "Illegal file name '%s'." % (filename)
294 if rcParams['verbose']:
295 #print msg
296 asaplog.push( msg )
297 print_log( 'ERROR' )
298 else:
299 raise IOError(msg)
300 if rcParams['verbose']:
301 try:
302 from IPython.genutils import page as pager
303 except ImportError:
304 from pydoc import pager
305 pager(info)
306 else:
307 return info
308
309 def get_spectrum(self, rowno):
310 """Return the spectrum for the current row in the scantable as a list.
311 Parameters:
312 rowno: the row number to retrieve the spectrum from
313 """
314 return self._getspectrum(rowno)
315
316 def get_mask(self, rowno):
317 """Return the mask for the current row in the scantable as a list.
318 Parameters:
319 rowno: the row number to retrieve the mask from
320 """
321 return self._getmask(rowno)
322
323 def set_spectrum(self, spec, rowno):
324 """Return the spectrum for the current row in the scantable as a list.
325 Parameters:
326 spec: the spectrum
327 rowno: the row number to set the spectrum for
328 """
329 assert(len(spec) == self.nchan())
330 return self._setspectrum(spec, rowno)
331
332 def get_selection(self):
333 """
334 Get the selection object currently set on this scantable.
335 Parameters:
336 none
337 Example:
338 sel = scan.get_selection()
339 sel.set_ifs(0) # select IF 0
340 scan.set_selection(sel) # apply modified selection
341 """
342 return selector(self._getselection())
343
344 def set_selection(self, selection=selector()):
345 """
346 Select a subset of the data. All following operations on this scantable
347 are only applied to thi selection.
348 Parameters:
349 selection: a selector object (default unset the selection)
350 Examples:
351 sel = selector() # create a selection object
352 self.set_scans([0, 3]) # select SCANNO 0 and 3
353 scan.set_selection(sel) # set the selection
354 scan.summary() # will only print summary of scanno 0 an 3
355 scan.set_selection() # unset the selection
356 """
357 self._setselection(selection)
358
359 def get_row(self, row=0, insitu=None):
360 """
361 Select a row in the scantable.
362 Return a scantable with single row.
363 Parameters:
364 row: row no of integration, default is 0.
365 insitu: if False a new scantable is returned.
366 Otherwise, the scaling is done in-situ
367 The default is taken from .asaprc (False)
368 """
369 if insitu is None: insitu = rcParams['insitu']
370 if not insitu:
371 workscan = self.copy()
372 else:
373 workscan = self
374 # Select a row
375 sel=selector()
376 sel.set_scans([workscan.getscan(row)])
377 sel.set_cycles([workscan.getcycle(row)])
378 sel.set_beams([workscan.getbeam(row)])
379 sel.set_ifs([workscan.getif(row)])
380 sel.set_polarisations([workscan.getpol(row)])
381 sel.set_name(workscan._getsourcename(row))
382 workscan.set_selection(sel)
383 if not workscan.nrow() == 1:
384 msg = "Cloud not identify single row. %d rows selected."%(workscan.nrow())
385 raise RuntimeError(msg)
386 del sel
387 if insitu:
388 self._assign(workscan)
389 else:
390 return workscan
391
392 #def stats(self, stat='stddev', mask=None):
393 def stats(self, stat='stddev', mask=None, form='3.3f'):
394 """
395 Determine the specified statistic of the current beam/if/pol
396 Takes a 'mask' as an optional parameter to specify which
397 channels should be excluded.
398 Parameters:
399 stat: 'min', 'max', 'min_abc', 'max_abc', 'sumsq', 'sum',
400 'mean', 'var', 'stddev', 'avdev', 'rms', 'median'
401 mask: an optional mask specifying where the statistic
402 should be determined.
403 form: format string to print statistic values
404 Example:
405 scan.set_unit('channel')
406 msk = scan.create_mask([100, 200], [500, 600])
407 scan.stats(stat='mean', mask=m)
408 """
409 if mask == None:
410 mask = []
411 axes = ['Beam', 'IF', 'Pol', 'Time']
412 if not self._check_ifs():
413 raise ValueError("Cannot apply mask as the IFs have different "
414 "number of channels. Please use setselection() "
415 "to select individual IFs")
416 rtnabc = False
417 if stat.lower().endswith('_abc'): rtnabc = True
418 getchan = False
419 if stat.lower().startswith('min') or stat.lower().startswith('max'):
420 chan = self._math._minmaxchan(self, mask, stat)
421 getchan = True
422 statvals = []
423 if not rtnabc: statvals = self._math._stats(self, mask, stat)
424
425 out = ''
426 axes = []
427 for i in range(self.nrow()):
428 axis = []
429 axis.append(self.getscan(i))
430 axis.append(self.getbeam(i))
431 axis.append(self.getif(i))
432 axis.append(self.getpol(i))
433 axis.append(self.getcycle(i))
434 axes.append(axis)
435 tm = self._gettime(i)
436 src = self._getsourcename(i)
437 refstr = ''
438 statunit= ''
439 if getchan:
440 qx, qy = self.chan2data(rowno=i, chan=chan[i])
441 if rtnabc:
442 statvals.append(qx['value'])
443 #refstr = '(value: %3.3f' % (qy['value'])+' ['+qy['unit']+'])'
444 refstr = ('(value: %'+form) % (qy['value'])+' ['+qy['unit']+'])'
445 statunit= '['+qx['unit']+']'
446 else:
447 #refstr = '(@ %3.3f' % (qx['value'])+' ['+qx['unit']+'])'
448 refstr = ('(@ %'+form) % (qx['value'])+' ['+qx['unit']+'])'
449 #statunit= ' ['+qy['unit']+']'
450 out += 'Scan[%d] (%s) ' % (axis[0], src)
451 out += 'Time[%s]:\n' % (tm)
452 if self.nbeam(-1) > 1: out += ' Beam[%d] ' % (axis[1])
453 if self.nif(-1) > 1: out += ' IF[%d] ' % (axis[2])
454 if self.npol(-1) > 1: out += ' Pol[%d] ' % (axis[3])
455 #out += '= %3.3f ' % (statvals[i]) +refstr+'\n'
456 out += ('= %'+form) % (statvals[i]) +' '+refstr+'\n'
457 out += "--------------------------------------------------\n"
458
459 if rcParams['verbose']:
460 import os
461 if os.environ.has_key( 'USER' ):
462 usr=os.environ['USER']
463 else:
464 import commands
465 usr=commands.getoutput( 'whoami' )
466 tmpfile='/tmp/tmp_'+usr+'_casapy_asap_scantable_stats'
467 f=open(tmpfile,'w')
468 print >> f, "--------------------------------------------------"
469 print >> f, " ", stat, statunit
470 print >> f, "--------------------------------------------------"
471 print >> f, out
472 f.close()
473 f=open(tmpfile,'r')
474 x=f.readlines()
475 f.close()
476 for xx in x:
477 asaplog.push( xx )
478 print_log()
479 #else:
480 #retval = { 'axesnames': ['scanno', 'beamno', 'ifno', 'polno', 'cycleno'],
481 # 'axes' : axes,
482 # 'data': statvals}
483 return statvals
484
485 def chan2data(self, rowno=0, chan=0):
486 """
487 Returns channel/frequency/velocity and spectral value
488 at an arbitrary row and channel in the scantable.
489 Parameters:
490 rowno: a row number in the scantable. Default is the
491 first row, i.e. rowno=0
492 chan: a channel in the scantable. Default is the first
493 channel, i.e. pos=0
494 """
495 if isinstance(rowno, int) and isinstance(chan, int):
496 qx = {'unit': self.get_unit(),
497 'value': self._getabcissa(rowno)[chan]}
498 qy = {'unit': self.get_fluxunit(),
499 'value': self._getspectrum(rowno)[chan]}
500 return qx, qy
501
502 def stddev(self, mask=None):
503 """
504 Determine the standard deviation of the current beam/if/pol
505 Takes a 'mask' as an optional parameter to specify which
506 channels should be excluded.
507 Parameters:
508 mask: an optional mask specifying where the standard
509 deviation should be determined.
510
511 Example:
512 scan.set_unit('channel')
513 msk = scan.create_mask([100, 200], [500, 600])
514 scan.stddev(mask=m)
515 """
516 return self.stats(stat='stddev', mask=mask);
517
518
519 def get_column_names(self):
520 """
521 Return a list of column names, which can be used for selection.
522 """
523 return list(Scantable.get_column_names(self))
524
525 def get_tsys(self):
526 """
527 Return the System temperatures.
528 Returns:
529 a list of Tsys values for the current selection
530 """
531
532 return self._row_callback(self._gettsys, "Tsys")
533
534 def _row_callback(self, callback, label):
535 axes = []
536 axesnames = ['scanno', 'beamno', 'ifno', 'polno', 'cycleno']
537 out = ""
538 outvec = []
539 for i in range(self.nrow()):
540 axis = []
541 axis.append(self.getscan(i))
542 axis.append(self.getbeam(i))
543 axis.append(self.getif(i))
544 axis.append(self.getpol(i))
545 axis.append(self.getcycle(i))
546 axes.append(axis)
547 tm = self._gettime(i)
548 src = self._getsourcename(i)
549 out += 'Scan[%d] (%s) ' % (axis[0], src)
550 out += 'Time[%s]:\n' % (tm)
551 if self.nbeam(-1) > 1: out += ' Beam[%d] ' % (axis[1])
552 if self.nif(-1) > 1: out += ' IF[%d] ' % (axis[2])
553 if self.npol(-1) > 1: out += ' Pol[%d] ' % (axis[3])
554 outvec.append(callback(i))
555 out += '= %3.3f\n' % (outvec[i])
556 out += "--------------------------------------------------\n"
557 if rcParams['verbose']:
558 asaplog.push("--------------------------------------------------")
559 asaplog.push(" %s" % (label))
560 asaplog.push("--------------------------------------------------")
561 asaplog.push(out)
562 print_log()
563 # disabled because the vector seems more useful
564 #retval = {'axesnames': axesnames, 'axes': axes, 'data': outvec}
565 return outvec
566
567 def _get_column(self, callback, row=-1):
568 """
569 """
570 if row == -1:
571 return [callback(i) for i in range(self.nrow())]
572 else:
573 if 0 <= row < self.nrow():
574 return callback(row)
575
576
577 def get_time(self, row=-1, asdatetime=False):
578 """
579 Get a list of time stamps for the observations.
580 Return a datetime object for each integration time stamp in the scantable.
581 Parameters:
582 row: row no of integration. Default -1 return all rows
583 asdatetime: return values as datetime objects rather than strings
584 Example:
585 none
586 """
587 from time import strptime
588 from datetime import datetime
589 times = self._get_column(self._gettime, row)
590 if not asdatetime:
591 return times
592 format = "%Y/%m/%d/%H:%M:%S"
593 if isinstance(times, list):
594 return [datetime(*strptime(i, format)[:6]) for i in times]
595 else:
596 return datetime(*strptime(times, format)[:6])
597
598
599 def get_inttime(self, row=-1):
600 """
601 Get a list of integration times for the observations.
602 Return a time in seconds for each integration in the scantable.
603 Parameters:
604 row: row no of integration. Default -1 return all rows.
605 Example:
606 none
607 """
608 return self._get_column(self._getinttime, row)
609
610
611 def get_sourcename(self, row=-1):
612 """
613 Get a list source names for the observations.
614 Return a string for each integration in the scantable.
615 Parameters:
616 row: row no of integration. Default -1 return all rows.
617 Example:
618 none
619 """
620 return self._get_column(self._getsourcename, row)
621
622 def get_elevation(self, row=-1):
623 """
624 Get a list of elevations for the observations.
625 Return a float for each integration in the scantable.
626 Parameters:
627 row: row no of integration. Default -1 return all rows.
628 Example:
629 none
630 """
631 return self._get_column(self._getelevation, row)
632
633 def get_azimuth(self, row=-1):
634 """
635 Get a list of azimuths for the observations.
636 Return a float for each integration in the scantable.
637 Parameters:
638 row: row no of integration. Default -1 return all rows.
639 Example:
640 none
641 """
642 return self._get_column(self._getazimuth, row)
643
644 def get_parangle(self, row=-1):
645 """
646 Get a list of parallactic angles for the observations.
647 Return a float for each integration in the scantable.
648 Parameters:
649 row: row no of integration. Default -1 return all rows.
650 Example:
651 none
652 """
653 return self._get_column(self._getparangle, row)
654
655 def get_direction(self, row=-1):
656 """
657 Get a list of Positions on the sky (direction) for the observations.
658 Return a float for each integration in the scantable.
659 Parameters:
660 row: row no of integration. Default -1 return all rows
661 Example:
662 none
663 """
664 return self._get_column(self._getdirection, row)
665
666 def get_directionval(self, row=-1):
667 """
668 Get a list of Positions on the sky (direction) for the observations.
669 Return a float for each integration in the scantable.
670 Parameters:
671 row: row no of integration. Default -1 return all rows
672 Example:
673 none
674 """
675 return self._get_column(self._getdirectionvec, row)
676
677 def set_unit(self, unit='channel'):
678 """
679 Set the unit for all following operations on this scantable
680 Parameters:
681 unit: optional unit, default is 'channel'
682 one of '*Hz', 'km/s', 'channel', ''
683 """
684 varlist = vars()
685 if unit in ['', 'pixel', 'channel']:
686 unit = ''
687 inf = list(self._getcoordinfo())
688 inf[0] = unit
689 self._setcoordinfo(inf)
690 self._add_history("set_unit", varlist)
691
692 def set_instrument(self, instr):
693 """
694 Set the instrument for subsequent processing.
695 Parameters:
696 instr: Select from 'ATPKSMB', 'ATPKSHOH', 'ATMOPRA',
697 'DSS-43' (Tid), 'CEDUNA', and 'HOBART'
698 """
699 self._setInstrument(instr)
700 self._add_history("set_instument", vars())
701 print_log()
702
703 def set_feedtype(self, feedtype):
704 """
705 Overwrite the feed type, which might not be set correctly.
706 Parameters:
707 feedtype: 'linear' or 'circular'
708 """
709 self._setfeedtype(feedtype)
710 self._add_history("set_feedtype", vars())
711 print_log()
712
713 def set_doppler(self, doppler='RADIO'):
714 """
715 Set the doppler for all following operations on this scantable.
716 Parameters:
717 doppler: One of 'RADIO', 'OPTICAL', 'Z', 'BETA', 'GAMMA'
718 """
719 varlist = vars()
720 inf = list(self._getcoordinfo())
721 inf[2] = doppler
722 self._setcoordinfo(inf)
723 self._add_history("set_doppler", vars())
724 print_log()
725
726 def set_freqframe(self, frame=None):
727 """
728 Set the frame type of the Spectral Axis.
729 Parameters:
730 frame: an optional frame type, default 'LSRK'. Valid frames are:
731 'REST', 'TOPO', 'LSRD', 'LSRK', 'BARY',
732 'GEO', 'GALACTO', 'LGROUP', 'CMB'
733 Examples:
734 scan.set_freqframe('BARY')
735 """
736 if frame is None: frame = rcParams['scantable.freqframe']
737 varlist = vars()
738 valid = ['REST', 'TOPO', 'LSRD', 'LSRK', 'BARY', \
739 'GEO', 'GALACTO', 'LGROUP', 'CMB']
740
741 if frame in valid:
742 inf = list(self._getcoordinfo())
743 inf[1] = frame
744 self._setcoordinfo(inf)
745 self._add_history("set_freqframe", varlist)
746 else:
747 msg = "Please specify a valid freq type. Valid types are:\n", valid
748 if rcParams['verbose']:
749 #print msg
750 asaplog.push( msg )
751 print_log( 'ERROR' )
752 else:
753 raise TypeError(msg)
754 print_log()
755
756 def set_dirframe(self, frame=""):
757 """
758 Set the frame type of the Direction on the sky.
759 Parameters:
760 frame: an optional frame type, default ''. Valid frames are:
761 'J2000', 'B1950', 'GALACTIC'
762 Examples:
763 scan.set_dirframe('GALACTIC')
764 """
765 varlist = vars()
766 try:
767 Scantable.set_dirframe(self, frame)
768 except RuntimeError, msg:
769 if rcParams['verbose']:
770 #print msg
771 print_log()
772 asaplog.push( msg.message )
773 print_log( 'ERROR' )
774 else:
775 raise
776 self._add_history("set_dirframe", varlist)
777
778 def get_unit(self):
779 """
780 Get the default unit set in this scantable
781 Returns:
782 A unit string
783 """
784 inf = self._getcoordinfo()
785 unit = inf[0]
786 if unit == '': unit = 'channel'
787 return unit
788
789 def get_abcissa(self, rowno=0):
790 """
791 Get the abcissa in the current coordinate setup for the currently
792 selected Beam/IF/Pol
793 Parameters:
794 rowno: an optional row number in the scantable. Default is the
795 first row, i.e. rowno=0
796 Returns:
797 The abcissa values and the format string (as a dictionary)
798 """
799 abc = self._getabcissa(rowno)
800 lbl = self._getabcissalabel(rowno)
801 print_log()
802 return abc, lbl
803
804 def flag(self, mask=None, unflag=False):
805 """
806 Flag the selected data using an optional channel mask.
807 Parameters:
808 mask: an optional channel mask, created with create_mask. Default
809 (no mask) is all channels.
810 unflag: if True, unflag the data
811 """
812 varlist = vars()
813 if mask is None:
814 mask = []
815 try:
816 self._flag(mask, unflag)
817 except RuntimeError, msg:
818 if rcParams['verbose']:
819 #print msg
820 print_log()
821 asaplog.push( msg.message )
822 print_log( 'ERROR' )
823 return
824 else: raise
825 self._add_history("flag", varlist)
826
827 def lag_flag(self, frequency, width=0.0, unit="GHz", insitu=None):
828 """
829 Flag the data in 'lag' space by providing a frequency to remove.
830 Flagged data in the scantable gets set to 0.0 before the fft.
831 No taper is applied.
832 Parameters:
833 frequency: the frequency (really a period within the bandwidth)
834 to remove
835 width: the width of the frequency to remove, to remove a
836 range of frequencies around the centre.
837 unit: the frequency unit (default "GHz")
838 Notes:
839 It is recommended to flag edges of the band or strong
840 signals beforehand.
841 """
842 if insitu is None: insitu = rcParams['insitu']
843 self._math._setinsitu(insitu)
844 varlist = vars()
845 base = { "GHz": 1000000000., "MHz": 1000000., "kHz": 1000., "Hz": 1. }
846 if not base.has_key(unit):
847 raise ValueError("%s is not a valid unit." % unit)
848 try:
849 s = scantable(self._math._lag_flag(self, frequency*base[unit],
850 width*base[unit]))
851 except RuntimeError, msg:
852 if rcParams['verbose']:
853 #print msg
854 print_log()
855 asaplog.push( msg.message )
856 print_log( 'ERROR' )
857 return
858 else: raise
859 s._add_history("lag_flag", varlist)
860 print_log()
861 if insitu:
862 self._assign(s)
863 else:
864 return s
865
866
867 def create_mask(self, *args, **kwargs):
868 """
869 Compute and return a mask based on [min, max] windows.
870 The specified windows are to be INCLUDED, when the mask is
871 applied.
872 Parameters:
873 [min, max], [min2, max2], ...
874 Pairs of start/end points (inclusive)specifying the regions
875 to be masked
876 invert: optional argument. If specified as True,
877 return an inverted mask, i.e. the regions
878 specified are EXCLUDED
879 row: create the mask using the specified row for
880 unit conversions, default is row=0
881 only necessary if frequency varies over rows.
882 Example:
883 scan.set_unit('channel')
884 a)
885 msk = scan.create_mask([400, 500], [800, 900])
886 # masks everything outside 400 and 500
887 # and 800 and 900 in the unit 'channel'
888
889 b)
890 msk = scan.create_mask([400, 500], [800, 900], invert=True)
891 # masks the regions between 400 and 500
892 # and 800 and 900 in the unit 'channel'
893 c)
894 mask only channel 400
895 msk = scan.create_mask([400, 400])
896 """
897 row = 0
898 if kwargs.has_key("row"):
899 row = kwargs.get("row")
900 data = self._getabcissa(row)
901 u = self._getcoordinfo()[0]
902 if rcParams['verbose']:
903 if u == "": u = "channel"
904 msg = "The current mask window unit is %s" % u
905 i = self._check_ifs()
906 if not i:
907 msg += "\nThis mask is only valid for IF=%d" % (self.getif(i))
908 asaplog.push(msg)
909 n = self.nchan()
910 msk = _n_bools(n, False)
911 # test if args is a 'list' or a 'normal *args - UGLY!!!
912
913 ws = (isinstance(args[-1][-1], int) or isinstance(args[-1][-1], float)) \
914 and args or args[0]
915 for window in ws:
916 if (len(window) != 2 or window[0] > window[1] ):
917 raise TypeError("A window needs to be defined as [min, max]")
918 for i in range(n):
919 if data[i] >= window[0] and data[i] <= window[1]:
920 msk[i] = True
921 if kwargs.has_key('invert'):
922 if kwargs.get('invert'):
923 msk = mask_not(msk)
924 print_log()
925 return msk
926
927 def get_masklist(self, mask=None, row=0):
928 """
929 Compute and return a list of mask windows, [min, max].
930 Parameters:
931 mask: channel mask, created with create_mask.
932 row: calcutate the masklist using the specified row
933 for unit conversions, default is row=0
934 only necessary if frequency varies over rows.
935 Returns:
936 [min, max], [min2, max2], ...
937 Pairs of start/end points (inclusive)specifying
938 the masked regions
939 """
940 if not (isinstance(mask,list) or isinstance(mask, tuple)):
941 raise TypeError("The mask should be list or tuple.")
942 if len(mask) < 2:
943 raise TypeError("The mask elements should be > 1")
944 if self.nchan() != len(mask):
945 msg = "Number of channels in scantable != number of mask elements"
946 raise TypeError(msg)
947 data = self._getabcissa(row)
948 u = self._getcoordinfo()[0]
949 if rcParams['verbose']:
950 if u == "": u = "channel"
951 msg = "The current mask window unit is %s" % u
952 i = self._check_ifs()
953 if not i:
954 msg += "\nThis mask is only valid for IF=%d" % (self.getif(i))
955 asaplog.push(msg)
956 masklist=[]
957 ist, ien = None, None
958 ist, ien=self.get_mask_indices(mask)
959 if ist is not None and ien is not None:
960 for i in xrange(len(ist)):
961 range=[data[ist[i]],data[ien[i]]]
962 range.sort()
963 masklist.append([range[0],range[1]])
964 return masklist
965
966 def get_mask_indices(self, mask=None):
967 """
968 Compute and Return lists of mask start indices and mask end indices.
969 Parameters:
970 mask: channel mask, created with create_mask.
971 Returns:
972 List of mask start indices and that of mask end indices,
973 i.e., [istart1,istart2,....], [iend1,iend2,....].
974 """
975 if not (isinstance(mask,list) or isinstance(mask, tuple)):
976 raise TypeError("The mask should be list or tuple.")
977 if len(mask) < 2:
978 raise TypeError("The mask elements should be > 1")
979 istart=[]
980 iend=[]
981 if mask[0]: istart.append(0)
982 for i in range(len(mask)-1):
983 if not mask[i] and mask[i+1]:
984 istart.append(i+1)
985 elif mask[i] and not mask[i+1]:
986 iend.append(i)
987 if mask[len(mask)-1]: iend.append(len(mask)-1)
988 if len(istart) != len(iend):
989 raise RuntimeError("Numbers of mask start != mask end.")
990 for i in range(len(istart)):
991 if istart[i] > iend[i]:
992 raise RuntimeError("Mask start index > mask end index")
993 break
994 return istart,iend
995
996# def get_restfreqs(self):
997# """
998# Get the restfrequency(s) stored in this scantable.
999# The return value(s) are always of unit 'Hz'
1000# Parameters:
1001# none
1002# Returns:
1003# a list of doubles
1004# """
1005# return list(self._getrestfreqs())
1006
1007 def get_restfreqs(self, ids=None):
1008 """
1009 Get the restfrequency(s) stored in this scantable.
1010 The return value(s) are always of unit 'Hz'
1011 Parameters:
1012 ids: (optional) a list of MOLECULE_ID for that restfrequency(s) to
1013 be retrieved
1014 Returns:
1015 dictionary containing ids and a list of doubles for each id
1016 """
1017 if ids is None:
1018 rfreqs={}
1019 idlist = self.getmolnos()
1020 for i in idlist:
1021 rfreqs[i]=list(self._getrestfreqs(i))
1022 return rfreqs
1023 else:
1024 if type(ids)==list or type(ids)==tuple:
1025 rfreqs={}
1026 for i in ids:
1027 rfreqs[i]=list(self._getrestfreqs(i))
1028 return rfreqs
1029 else:
1030 return list(self._getrestfreqs(ids))
1031 #return list(self._getrestfreqs(ids))
1032
1033 def set_restfreqs(self, freqs=None, unit='Hz'):
1034 """
1035 ********NEED TO BE UPDATED begin************
1036 Set or replace the restfrequency specified and
1037 If the 'freqs' argument holds a scalar,
1038 then that rest frequency will be applied to all the selected
1039 data. If the 'freqs' argument holds
1040 a vector, then it MUST be of equal or smaller length than
1041 the number of IFs (and the available restfrequencies will be
1042 replaced by this vector). In this case, *all* data have
1043 the restfrequency set per IF according
1044 to the corresponding value you give in the 'freqs' vector.
1045 E.g. 'freqs=[1e9, 2e9]' would mean IF 0 gets restfreq 1e9 and
1046 IF 1 gets restfreq 2e9.
1047 ********NEED TO BE UPDATED end************
1048 You can also specify the frequencies via a linecatalog.
1049
1050 Parameters:
1051 freqs: list of rest frequency values or string idenitfiers
1052 unit: unit for rest frequency (default 'Hz')
1053
1054 Example:
1055 # set the given restfrequency for the all currently selected IFs
1056 scan.set_restfreqs(freqs=1.4e9)
1057 # set multiple restfrequencies to all the selected data
1058 scan.set_restfreqs(freqs=[1.4e9, 1.41e9, 1.42e9])
1059 # If the number of IFs in the data is >= 2 the IF0 gets the first
1060 # value IF1 the second... NOTE that freqs needs to be
1061 # specified in list of list (e.g. [[],[],...] ).
1062 scan.set_restfreqs(freqs=[[1.4e9],[1.67e9]])
1063 #set the given restfrequency for the whole table (by name)
1064 scan.set_restfreqs(freqs="OH1667")
1065
1066 Note:
1067 To do more sophisticate Restfrequency setting, e.g. on a
1068 source and IF basis, use scantable.set_selection() before using
1069 this function.
1070 # provide your scantable is call scan
1071 selection = selector()
1072 selection.set_name("ORION*")
1073 selection.set_ifs([1])
1074 scan.set_selection(selection)
1075 scan.set_restfreqs(freqs=86.6e9)
1076
1077 """
1078 varlist = vars()
1079 from asap import linecatalog
1080 # simple value
1081 if isinstance(freqs, int) or isinstance(freqs, float):
1082 # TT mod
1083 #self._setrestfreqs(freqs, "",unit)
1084 self._setrestfreqs([freqs], [""],unit)
1085 # list of values
1086 elif isinstance(freqs, list) or isinstance(freqs, tuple):
1087 # list values are scalars
1088 if isinstance(freqs[-1], int) or isinstance(freqs[-1], float):
1089 self._setrestfreqs(freqs, [""],unit)
1090 # list values are tuples, (value, name)
1091 elif isinstance(freqs[-1], dict):
1092 #sel = selector()
1093 #savesel = self._getselection()
1094 #iflist = self.getifnos()
1095 #for i in xrange(len(freqs)):
1096 # sel.set_ifs(iflist[i])
1097 # self._setselection(sel)
1098 # self._setrestfreqs(freqs[i], "",unit)
1099 #self._setselection(savesel)
1100 self._setrestfreqs(freqs["value"],
1101 freqs["name"], "MHz")
1102 elif isinstance(freqs[-1], list) or isinstance(freqs[-1], tuple):
1103 sel = selector()
1104 savesel = self._getselection()
1105 iflist = self.getifnos()
1106 if len(freqs)>len(iflist):
1107 raise ValueError("number of elements in list of list exeeds the current IF selections")
1108 for i in xrange(len(freqs)):
1109 sel.set_ifs(iflist[i])
1110 self._setselection(sel)
1111 self._setrestfreqs(freqs[i]["value"],
1112 freqs[i]["name"], "MHz")
1113 self._setselection(savesel)
1114 # freqs are to be taken from a linecatalog
1115 elif isinstance(freqs, linecatalog):
1116 sel = selector()
1117 savesel = self._getselection()
1118 for i in xrange(freqs.nrow()):
1119 sel.set_ifs(iflist[i])
1120 self._setselection(sel)
1121 self._setrestfreqs(freqs.get_frequency(i),
1122 freqs.get_name(i), "MHz")
1123 # ensure that we are not iterating past nIF
1124 if i == self.nif()-1: break
1125 self._setselection(savesel)
1126 else:
1127 return
1128 self._add_history("set_restfreqs", varlist)
1129
1130 def shift_refpix(self, delta):
1131 """
1132 Shift the reference pixel of the Spectra Coordinate by an
1133 integer amount.
1134 Parameters:
1135 delta: the amount to shift by
1136 Note:
1137 Be careful using this with broadband data.
1138 """
1139 Scantable.shift(self, delta)
1140
1141 def history(self, filename=None):
1142 """
1143 Print the history. Optionally to a file.
1144 Parameters:
1145 filename: The name of the file to save the history to.
1146 """
1147 hist = list(self._gethistory())
1148 out = "-"*80
1149 for h in hist:
1150 if h.startswith("---"):
1151 out += "\n"+h
1152 else:
1153 items = h.split("##")
1154 date = items[0]
1155 func = items[1]
1156 items = items[2:]
1157 out += "\n"+date+"\n"
1158 out += "Function: %s\n Parameters:" % (func)
1159 for i in items:
1160 s = i.split("=")
1161 out += "\n %s = %s" % (s[0], s[1])
1162 out += "\n"+"-"*80
1163 if filename is not None:
1164 if filename is "":
1165 filename = 'scantable_history.txt'
1166 import os
1167 filename = os.path.expandvars(os.path.expanduser(filename))
1168 if not os.path.isdir(filename):
1169 data = open(filename, 'w')
1170 data.write(out)
1171 data.close()
1172 else:
1173 msg = "Illegal file name '%s'." % (filename)
1174 if rcParams['verbose']:
1175 #print msg
1176 asaplog.push( msg )
1177 print_log( 'ERROR' )
1178 else:
1179 raise IOError(msg)
1180 if rcParams['verbose']:
1181 try:
1182 from IPython.genutils import page as pager
1183 except ImportError:
1184 from pydoc import pager
1185 pager(out)
1186 else:
1187 return out
1188 return
1189 #
1190 # Maths business
1191 #
1192
1193 def average_time(self, mask=None, scanav=False, weight='tint', align=False):
1194 """
1195 Return the (time) weighted average of a scan.
1196 Note:
1197 in channels only - align if necessary
1198 Parameters:
1199 mask: an optional mask (only used for 'var' and 'tsys'
1200 weighting)
1201 scanav: True averages each scan separately
1202 False (default) averages all scans together,
1203 weight: Weighting scheme.
1204 'none' (mean no weight)
1205 'var' (1/var(spec) weighted)
1206 'tsys' (1/Tsys**2 weighted)
1207 'tint' (integration time weighted)
1208 'tintsys' (Tint/Tsys**2)
1209 'median' ( median averaging)
1210 The default is 'tint'
1211 align: align the spectra in velocity before averaging. It takes
1212 the time of the first spectrum as reference time.
1213 Example:
1214 # time average the scantable without using a mask
1215 newscan = scan.average_time()
1216 """
1217 varlist = vars()
1218 if weight is None: weight = 'TINT'
1219 if mask is None: mask = ()
1220 if scanav: scanav = "SCAN"
1221 else: scanav = "NONE"
1222 scan = (self, )
1223 try:
1224 if align:
1225 scan = (self.freq_align(insitu=False), )
1226 s = None
1227 if weight.upper() == 'MEDIAN':
1228 s = scantable(self._math._averagechannel(scan[0], 'MEDIAN',
1229 scanav))
1230 else:
1231 s = scantable(self._math._average(scan, mask, weight.upper(),
1232 scanav))
1233 except RuntimeError, msg:
1234 if rcParams['verbose']:
1235 #print msg
1236 print_log()
1237 asaplog.push( msg.message )
1238 print_log( 'ERROR' )
1239 return
1240 else: raise
1241 s._add_history("average_time", varlist)
1242 print_log()
1243 return s
1244
1245 def convert_flux(self, jyperk=None, eta=None, d=None, insitu=None):
1246 """
1247 Return a scan where all spectra are converted to either
1248 Jansky or Kelvin depending upon the flux units of the scan table.
1249 By default the function tries to look the values up internally.
1250 If it can't find them (or if you want to over-ride), you must
1251 specify EITHER jyperk OR eta (and D which it will try to look up
1252 also if you don't set it). jyperk takes precedence if you set both.
1253 Parameters:
1254 jyperk: the Jy / K conversion factor
1255 eta: the aperture efficiency
1256 d: the geomtric diameter (metres)
1257 insitu: if False a new scantable is returned.
1258 Otherwise, the scaling is done in-situ
1259 The default is taken from .asaprc (False)
1260 """
1261 if insitu is None: insitu = rcParams['insitu']
1262 self._math._setinsitu(insitu)
1263 varlist = vars()
1264 if jyperk is None: jyperk = -1.0
1265 if d is None: d = -1.0
1266 if eta is None: eta = -1.0
1267 s = scantable(self._math._convertflux(self, d, eta, jyperk))
1268 s._add_history("convert_flux", varlist)
1269 print_log()
1270 if insitu: self._assign(s)
1271 else: return s
1272
1273 def gain_el(self, poly=None, filename="", method="linear", insitu=None):
1274 """
1275 Return a scan after applying a gain-elevation correction.
1276 The correction can be made via either a polynomial or a
1277 table-based interpolation (and extrapolation if necessary).
1278 You specify polynomial coefficients, an ascii table or neither.
1279 If you specify neither, then a polynomial correction will be made
1280 with built in coefficients known for certain telescopes (an error
1281 will occur if the instrument is not known).
1282 The data and Tsys are *divided* by the scaling factors.
1283 Parameters:
1284 poly: Polynomial coefficients (default None) to compute a
1285 gain-elevation correction as a function of
1286 elevation (in degrees).
1287 filename: The name of an ascii file holding correction factors.
1288 The first row of the ascii file must give the column
1289 names and these MUST include columns
1290 "ELEVATION" (degrees) and "FACTOR" (multiply data
1291 by this) somewhere.
1292 The second row must give the data type of the
1293 column. Use 'R' for Real and 'I' for Integer.
1294 An example file would be
1295 (actual factors are arbitrary) :
1296
1297 TIME ELEVATION FACTOR
1298 R R R
1299 0.1 0 0.8
1300 0.2 20 0.85
1301 0.3 40 0.9
1302 0.4 60 0.85
1303 0.5 80 0.8
1304 0.6 90 0.75
1305 method: Interpolation method when correcting from a table.
1306 Values are "nearest", "linear" (default), "cubic"
1307 and "spline"
1308 insitu: if False a new scantable is returned.
1309 Otherwise, the scaling is done in-situ
1310 The default is taken from .asaprc (False)
1311 """
1312
1313 if insitu is None: insitu = rcParams['insitu']
1314 self._math._setinsitu(insitu)
1315 varlist = vars()
1316 if poly is None:
1317 poly = ()
1318 from os.path import expandvars
1319 filename = expandvars(filename)
1320 s = scantable(self._math._gainel(self, poly, filename, method))
1321 s._add_history("gain_el", varlist)
1322 print_log()
1323 if insitu: self._assign(s)
1324 else: return s
1325
1326 def freq_align(self, reftime=None, method='cubic', insitu=None):
1327 """
1328 Return a scan where all rows have been aligned in frequency/velocity.
1329 The alignment frequency frame (e.g. LSRK) is that set by function
1330 set_freqframe.
1331 Parameters:
1332 reftime: reference time to align at. By default, the time of
1333 the first row of data is used.
1334 method: Interpolation method for regridding the spectra.
1335 Choose from "nearest", "linear", "cubic" (default)
1336 and "spline"
1337 insitu: if False a new scantable is returned.
1338 Otherwise, the scaling is done in-situ
1339 The default is taken from .asaprc (False)
1340 """
1341 if insitu is None: insitu = rcParams["insitu"]
1342 self._math._setinsitu(insitu)
1343 varlist = vars()
1344 if reftime is None: reftime = ""
1345 s = scantable(self._math._freq_align(self, reftime, method))
1346 s._add_history("freq_align", varlist)
1347 print_log()
1348 if insitu: self._assign(s)
1349 else: return s
1350
1351 def opacity(self, tau, insitu=None):
1352 """
1353 Apply an opacity correction. The data
1354 and Tsys are multiplied by the correction factor.
1355 Parameters:
1356 tau: Opacity from which the correction factor is
1357 exp(tau*ZD)
1358 where ZD is the zenith-distance
1359 insitu: if False a new scantable is returned.
1360 Otherwise, the scaling is done in-situ
1361 The default is taken from .asaprc (False)
1362 """
1363 if insitu is None: insitu = rcParams['insitu']
1364 self._math._setinsitu(insitu)
1365 varlist = vars()
1366 s = scantable(self._math._opacity(self, tau))
1367 s._add_history("opacity", varlist)
1368 print_log()
1369 if insitu: self._assign(s)
1370 else: return s
1371
1372 def bin(self, width=5, insitu=None):
1373 """
1374 Return a scan where all spectra have been binned up.
1375 Parameters:
1376 width: The bin width (default=5) in pixels
1377 insitu: if False a new scantable is returned.
1378 Otherwise, the scaling is done in-situ
1379 The default is taken from .asaprc (False)
1380 """
1381 if insitu is None: insitu = rcParams['insitu']
1382 self._math._setinsitu(insitu)
1383 varlist = vars()
1384 s = scantable(self._math._bin(self, width))
1385 s._add_history("bin", varlist)
1386 print_log()
1387 if insitu: self._assign(s)
1388 else: return s
1389
1390
1391 def resample(self, width=5, method='cubic', insitu=None):
1392 """
1393 Return a scan where all spectra have been binned up.
1394
1395 Parameters:
1396 width: The bin width (default=5) in pixels
1397 method: Interpolation method when correcting from a table.
1398 Values are "nearest", "linear", "cubic" (default)
1399 and "spline"
1400 insitu: if False a new scantable is returned.
1401 Otherwise, the scaling is done in-situ
1402 The default is taken from .asaprc (False)
1403 """
1404 if insitu is None: insitu = rcParams['insitu']
1405 self._math._setinsitu(insitu)
1406 varlist = vars()
1407 s = scantable(self._math._resample(self, method, width))
1408 s._add_history("resample", varlist)
1409 print_log()
1410 if insitu: self._assign(s)
1411 else: return s
1412
1413
1414 def average_pol(self, mask=None, weight='none'):
1415 """
1416 Average the Polarisations together.
1417 Parameters:
1418 mask: An optional mask defining the region, where the
1419 averaging will be applied. The output will have all
1420 specified points masked.
1421 weight: Weighting scheme. 'none' (default), 'var' (1/var(spec)
1422 weighted), or 'tsys' (1/Tsys**2 weighted)
1423 """
1424 varlist = vars()
1425 if mask is None:
1426 mask = ()
1427 s = scantable(self._math._averagepol(self, mask, weight.upper()))
1428 s._add_history("average_pol", varlist)
1429 print_log()
1430 return s
1431
1432 def average_beam(self, mask=None, weight='none'):
1433 """
1434 Average the Beams together.
1435 Parameters:
1436 mask: An optional mask defining the region, where the
1437 averaging will be applied. The output will have all
1438 specified points masked.
1439 weight: Weighting scheme. 'none' (default), 'var' (1/var(spec)
1440 weighted), or 'tsys' (1/Tsys**2 weighted)
1441 """
1442 varlist = vars()
1443 if mask is None:
1444 mask = ()
1445 s = scantable(self._math._averagebeams(self, mask, weight.upper()))
1446 s._add_history("average_beam", varlist)
1447 print_log()
1448 return s
1449
1450 def convert_pol(self, poltype=None):
1451 """
1452 Convert the data to a different polarisation type.
1453 Parameters:
1454 poltype: The new polarisation type. Valid types are:
1455 "linear", "stokes" and "circular"
1456 """
1457 varlist = vars()
1458 try:
1459 s = scantable(self._math._convertpol(self, poltype))
1460 except RuntimeError, msg:
1461 if rcParams['verbose']:
1462 #print msg
1463 print_log()
1464 asaplog.push( msg.message )
1465 print_log( 'ERROR' )
1466 return
1467 else:
1468 raise
1469 s._add_history("convert_pol", varlist)
1470 print_log()
1471 return s
1472
1473 def smooth(self, kernel="hanning", width=5.0, insitu=None):
1474 """
1475 Smooth the spectrum by the specified kernel (conserving flux).
1476 Parameters:
1477 kernel: The type of smoothing kernel. Select from
1478 'hanning' (default), 'gaussian', 'boxcar' and
1479 'rmedian'
1480 width: The width of the kernel in pixels. For hanning this is
1481 ignored otherwise it defauls to 5 pixels.
1482 For 'gaussian' it is the Full Width Half
1483 Maximum. For 'boxcar' it is the full width.
1484 For 'rmedian' it is the half width.
1485 insitu: if False a new scantable is returned.
1486 Otherwise, the scaling is done in-situ
1487 The default is taken from .asaprc (False)
1488 Example:
1489 none
1490 """
1491 if insitu is None: insitu = rcParams['insitu']
1492 self._math._setinsitu(insitu)
1493 varlist = vars()
1494 s = scantable(self._math._smooth(self, kernel.lower(), width))
1495 s._add_history("smooth", varlist)
1496 print_log()
1497 if insitu: self._assign(s)
1498 else: return s
1499
1500
1501 def poly_baseline(self, mask=None, order=0, plot=False, uselin=False, insitu=None):
1502 """
1503 Return a scan which has been baselined (all rows) by a polynomial.
1504 Parameters:
1505 mask: an optional mask
1506 order: the order of the polynomial (default is 0)
1507 plot: plot the fit and the residual. In this each
1508 indivual fit has to be approved, by typing 'y'
1509 or 'n'
1510 uselin: use linear polynomial fit
1511 insitu: if False a new scantable is returned.
1512 Otherwise, the scaling is done in-situ
1513 The default is taken from .asaprc (False)
1514 Example:
1515 # return a scan baselined by a third order polynomial,
1516 # not using a mask
1517 bscan = scan.poly_baseline(order=3)
1518 """
1519 if insitu is None: insitu = rcParams['insitu']
1520 if not insitu:
1521 workscan = self.copy()
1522 else:
1523 workscan = self
1524 varlist = vars()
1525 if mask is None:
1526 mask = [True for i in xrange(self.nchan(-1))]
1527
1528 from asap.asapfitter import fitter
1529 try:
1530 f = fitter()
1531 if uselin:
1532 f.set_function(lpoly=order)
1533 else:
1534 f.set_function(poly=order)
1535
1536 rows = range(self.nrow())
1537 if len(rows) > 0:
1538 self.blpars = []
1539
1540 for r in rows:
1541 # take into account flagtra info (CAS-1434)
1542 flagtra = self._getmask(r)
1543 actualmask = mask[:]
1544 if len(actualmask) == 0:
1545 actualmask = list(flagtra[:])
1546 else:
1547 if len(actualmask) != len(flagtra):
1548 raise RuntimeError, "Mask and flagtra have different length"
1549 else:
1550 for i in range(0, len(actualmask)):
1551 actualmask[i] = actualmask[i] and flagtra[i]
1552 f.set_scan(self, actualmask)
1553 f.x = self._getabcissa(r)
1554 f.y = self._getspectrum(r)
1555 f.data = None
1556 f.fit()
1557 workscan._setspectrum(f.fitter.getresidual(), r)
1558 fpar = f.get_parameters()
1559 self.blpars.append(fpar)
1560
1561 #f.set_scan(self, mask)
1562 #s = f.auto_fit(insitu, plot=plot)
1563 ## Save parameters of baseline fits as a class attribute.
1564 ## NOTICE: It does not reflect changes in scantable!
1565 #self.blpars = f.blpars
1566 workscan._add_history("poly_baseline", varlist)
1567 print_log()
1568 if insitu: self._assign(workscan)
1569 else: return workscan
1570 except RuntimeError:
1571 msg = "The fit failed, possibly because it didn't converge."
1572 if rcParams['verbose']:
1573 #print msg
1574 print_log()
1575 asaplog.push( msg.message )
1576 print_log( 'ERROR' )
1577 return
1578 else:
1579 raise RuntimeError(msg)
1580
1581
1582 def auto_poly_baseline(self, mask=[], edge=(0, 0), order=0,
1583 threshold=3, chan_avg_limit=1, plot=False,
1584 insitu=None):
1585 """
1586 Return a scan which has been baselined (all rows) by a polynomial.
1587 Spectral lines are detected first using linefinder and masked out
1588 to avoid them affecting the baseline solution.
1589
1590 Parameters:
1591 mask: an optional mask retreived from scantable
1592 edge: an optional number of channel to drop at
1593 the edge of spectrum. If only one value is
1594 specified, the same number will be dropped from
1595 both sides of the spectrum. Default is to keep
1596 all channels. Nested tuples represent individual
1597 edge selection for different IFs (a number of spectral
1598 channels can be different)
1599 order: the order of the polynomial (default is 0)
1600 threshold: the threshold used by line finder. It is better to
1601 keep it large as only strong lines affect the
1602 baseline solution.
1603 chan_avg_limit:
1604 a maximum number of consequtive spectral channels to
1605 average during the search of weak and broad lines.
1606 The default is no averaging (and no search for weak
1607 lines). If such lines can affect the fitted baseline
1608 (e.g. a high order polynomial is fitted), increase this
1609 parameter (usually values up to 8 are reasonable). Most
1610 users of this method should find the default value
1611 sufficient.
1612 plot: plot the fit and the residual. In this each
1613 indivual fit has to be approved, by typing 'y'
1614 or 'n'
1615 insitu: if False a new scantable is returned.
1616 Otherwise, the scaling is done in-situ
1617 The default is taken from .asaprc (False)
1618
1619 Example:
1620 scan2=scan.auto_poly_baseline(order=7)
1621 """
1622 if insitu is None: insitu = rcParams['insitu']
1623 varlist = vars()
1624 from asap.asapfitter import fitter
1625 from asap.asaplinefind import linefinder
1626 from asap import _is_sequence_or_number as _is_valid
1627
1628 # check whether edge is set up for each IF individually
1629 individualedge = False;
1630 if len(edge) > 1:
1631 if isinstance(edge[0], list) or isinstance(edge[0], tuple):
1632 individualedge = True;
1633
1634 if not _is_valid(edge, int) and not individualedge:
1635 raise ValueError, "Parameter 'edge' has to be an integer or a \
1636 pair of integers specified as a tuple. Nested tuples are allowed \
1637 to make individual selection for different IFs."
1638
1639 curedge = (0, 0)
1640 if individualedge:
1641 for edgepar in edge:
1642 if not _is_valid(edgepar, int):
1643 raise ValueError, "Each element of the 'edge' tuple has \
1644 to be a pair of integers or an integer."
1645 else:
1646 curedge = edge;
1647
1648 # setup fitter
1649 f = fitter()
1650 f.set_function(poly=order)
1651
1652 # setup line finder
1653 fl = linefinder()
1654 fl.set_options(threshold=threshold,avg_limit=chan_avg_limit)
1655
1656 if not insitu:
1657 workscan = self.copy()
1658 else:
1659 workscan = self
1660
1661 fl.set_scan(workscan)
1662
1663 rows = range(workscan.nrow())
1664 # Save parameters of baseline fits & masklists as a class attribute.
1665 # NOTICE: It does not reflect changes in scantable!
1666 if len(rows) > 0:
1667 self.blpars=[]
1668 self.masklists=[]
1669 asaplog.push("Processing:")
1670 for r in rows:
1671 msg = " Scan[%d] Beam[%d] IF[%d] Pol[%d] Cycle[%d]" % \
1672 (workscan.getscan(r), workscan.getbeam(r), workscan.getif(r), \
1673 workscan.getpol(r), workscan.getcycle(r))
1674 asaplog.push(msg, False)
1675
1676 # figure out edge parameter
1677 if individualedge:
1678 if len(edge) >= workscan.getif(r):
1679 raise RuntimeError, "Number of edge elements appear to " \
1680 "be less than the number of IFs"
1681 curedge = edge[workscan.getif(r)]
1682
1683 # take into account flagtra info (CAS-1434)
1684 flagtra = workscan._getmask(r)
1685 actualmask = mask[:]
1686 if len(actualmask) == 0:
1687 actualmask = list(flagtra[:])
1688 else:
1689 if len(actualmask) != len(flagtra):
1690 raise RuntimeError, "Mask and flagtra have different length"
1691 else:
1692 for i in range(0, len(actualmask)):
1693 actualmask[i] = actualmask[i] and flagtra[i]
1694
1695 # setup line finder
1696 fl.find_lines(r, actualmask, curedge)
1697 outmask=fl.get_mask()
1698 f.set_scan(workscan, fl.get_mask())
1699 f.x = workscan._getabcissa(r)
1700 f.y = workscan._getspectrum(r)
1701 f.data = None
1702 f.fit()
1703
1704 # Show mask list
1705 masklist=workscan.get_masklist(fl.get_mask(),row=r)
1706 msg = "mask range: "+str(masklist)
1707 asaplog.push(msg, False)
1708
1709 fpar = f.get_parameters()
1710 if plot:
1711 f.plot(residual=True)
1712 x = raw_input("Accept fit ( [y]/n ): ")
1713 if x.upper() == 'N':
1714 self.blpars.append(None)
1715 self.masklists.append(None)
1716 continue
1717 workscan._setspectrum(f.fitter.getresidual(), r)
1718 self.blpars.append(fpar)
1719 self.masklists.append(masklist)
1720 if plot:
1721 f._p.unmap()
1722 f._p = None
1723 workscan._add_history("auto_poly_baseline", varlist)
1724 if insitu:
1725 self._assign(workscan)
1726 else:
1727 return workscan
1728
1729 def rotate_linpolphase(self, angle):
1730 """
1731 Rotate the phase of the complex polarization O=Q+iU correlation.
1732 This is always done in situ in the raw data. So if you call this
1733 function more than once then each call rotates the phase further.
1734 Parameters:
1735 angle: The angle (degrees) to rotate (add) by.
1736 Examples:
1737 scan.rotate_linpolphase(2.3)
1738 """
1739 varlist = vars()
1740 self._math._rotate_linpolphase(self, angle)
1741 self._add_history("rotate_linpolphase", varlist)
1742 print_log()
1743 return
1744
1745
1746 def rotate_xyphase(self, angle):
1747 """
1748 Rotate the phase of the XY correlation. This is always done in situ
1749 in the data. So if you call this function more than once
1750 then each call rotates the phase further.
1751 Parameters:
1752 angle: The angle (degrees) to rotate (add) by.
1753 Examples:
1754 scan.rotate_xyphase(2.3)
1755 """
1756 varlist = vars()
1757 self._math._rotate_xyphase(self, angle)
1758 self._add_history("rotate_xyphase", varlist)
1759 print_log()
1760 return
1761
1762 def swap_linears(self):
1763 """
1764 Swap the linear polarisations XX and YY, or better the first two
1765 polarisations as this also works for ciculars.
1766 """
1767 varlist = vars()
1768 self._math._swap_linears(self)
1769 self._add_history("swap_linears", varlist)
1770 print_log()
1771 return
1772
1773 def invert_phase(self):
1774 """
1775 Invert the phase of the complex polarisation
1776 """
1777 varlist = vars()
1778 self._math._invert_phase(self)
1779 self._add_history("invert_phase", varlist)
1780 print_log()
1781 return
1782
1783 def add(self, offset, insitu=None):
1784 """
1785 Return a scan where all spectra have the offset added
1786 Parameters:
1787 offset: the offset
1788 insitu: if False a new scantable is returned.
1789 Otherwise, the scaling is done in-situ
1790 The default is taken from .asaprc (False)
1791 """
1792 if insitu is None: insitu = rcParams['insitu']
1793 self._math._setinsitu(insitu)
1794 varlist = vars()
1795 s = scantable(self._math._unaryop(self, offset, "ADD", False))
1796 s._add_history("add", varlist)
1797 print_log()
1798 if insitu:
1799 self._assign(s)
1800 else:
1801 return s
1802
1803 def scale(self, factor, tsys=True, insitu=None):
1804 """
1805 Return a scan where all spectra are scaled by the give 'factor'
1806 Parameters:
1807 factor: the scaling factor
1808 insitu: if False a new scantable is returned.
1809 Otherwise, the scaling is done in-situ
1810 The default is taken from .asaprc (False)
1811 tsys: if True (default) then apply the operation to Tsys
1812 as well as the data
1813 """
1814 if insitu is None: insitu = rcParams['insitu']
1815 self._math._setinsitu(insitu)
1816 varlist = vars()
1817 s = scantable(self._math._unaryop(self, factor, "MUL", tsys))
1818 s._add_history("scale", varlist)
1819 print_log()
1820 if insitu:
1821 self._assign(s)
1822 else:
1823 return s
1824
1825 def set_sourcetype(self, match, matchtype="pattern",
1826 sourcetype="reference"):
1827 """
1828 Set the type of the source to be an source or reference scan
1829 using the provided pattern:
1830 Parameters:
1831 match: a Unix style pattern, regular expression or selector
1832 matchtype: 'pattern' (default) UNIX style pattern or
1833 'regex' regular expression
1834 sourcetype: the type of the source to use (source/reference)
1835 """
1836 varlist = vars()
1837 basesel = self.get_selection()
1838 stype = -1
1839 if sourcetype.lower().startswith("r"):
1840 stype = 1
1841 elif sourcetype.lower().startswith("s"):
1842 stype = 0
1843 else:
1844 raise ValueError("Illegal sourcetype use s(ource) or r(eference)")
1845 if matchtype.lower().startswith("p"):
1846 matchtype = "pattern"
1847 elif matchtype.lower().startswith("r"):
1848 matchtype = "regex"
1849 else:
1850 raise ValueError("Illegal matchtype, use p(attern) or r(egex)")
1851 sel = selector()
1852 if isinstance(match, selector):
1853 sel = match
1854 else:
1855 sel.set_query("SRCNAME == %s('%s')" % (matchtype, match))
1856 self.set_selection(basesel+sel)
1857 self._setsourcetype(stype)
1858 self.set_selection(basesel)
1859 s._add_history("set_sourcetype", varlist)
1860
1861 def auto_quotient(self, preserve=True, mode='paired', verify=False):
1862 """
1863 This function allows to build quotients automatically.
1864 It assumes the observation to have the same number of
1865 "ons" and "offs"
1866 Parameters:
1867 preserve: you can preserve (default) the continuum or
1868 remove it. The equations used are
1869 preserve: Output = Toff * (on/off) - Toff
1870 remove: Output = Toff * (on/off) - Ton
1871 mode: the on/off detection mode
1872 'paired' (default)
1873 identifies 'off' scans by the
1874 trailing '_R' (Mopra/Parkes) or
1875 '_e'/'_w' (Tid) and matches
1876 on/off pairs from the observing pattern
1877 'time'
1878 finds the closest off in time
1879
1880 """
1881 modes = ["time", "paired"]
1882 if not mode in modes:
1883 msg = "please provide valid mode. Valid modes are %s" % (modes)
1884 raise ValueError(msg)
1885 varlist = vars()
1886 s = None
1887 if mode.lower() == "paired":
1888 basesel = self.get_selection()
1889 sel = selector()+basesel
1890 sel.set_query("SRCTYPE==1")
1891 self.set_selection(sel)
1892 offs = self.copy()
1893 sel.set_query("SRCTYPE==0")
1894 self.set_selection(sel)
1895 ons = self.copy()
1896 s = scantable(self._math._quotient(ons, offs, preserve))
1897 self.set_selection(basesel)
1898 elif mode.lower() == "time":
1899 s = scantable(self._math._auto_quotient(self, mode, preserve))
1900 s._add_history("auto_quotient", varlist)
1901 print_log()
1902 return s
1903
1904 def mx_quotient(self, mask = None, weight='median', preserve=True):
1905 """
1906 Form a quotient using "off" beams when observing in "MX" mode.
1907 Parameters:
1908 mask: an optional mask to be used when weight == 'stddev'
1909 weight: How to average the off beams. Default is 'median'.
1910 preserve: you can preserve (default) the continuum or
1911 remove it. The equations used are
1912 preserve: Output = Toff * (on/off) - Toff
1913 remove: Output = Toff * (on/off) - Ton
1914 """
1915 if mask is None: mask = ()
1916 varlist = vars()
1917 on = scantable(self._math._mx_extract(self, 'on'))
1918 preoff = scantable(self._math._mx_extract(self, 'off'))
1919 off = preoff.average_time(mask=mask, weight=weight, scanav=False)
1920 from asapmath import quotient
1921 q = quotient(on, off, preserve)
1922 q._add_history("mx_quotient", varlist)
1923 print_log()
1924 return q
1925
1926 def freq_switch(self, insitu=None):
1927 """
1928 Apply frequency switching to the data.
1929 Parameters:
1930 insitu: if False a new scantable is returned.
1931 Otherwise, the swictching is done in-situ
1932 The default is taken from .asaprc (False)
1933 Example:
1934 none
1935 """
1936 if insitu is None: insitu = rcParams['insitu']
1937 self._math._setinsitu(insitu)
1938 varlist = vars()
1939 s = scantable(self._math._freqswitch(self))
1940 s._add_history("freq_switch", varlist)
1941 print_log()
1942 if insitu: self._assign(s)
1943 else: return s
1944
1945 def recalc_azel(self):
1946 """
1947 Recalculate the azimuth and elevation for each position.
1948 Parameters:
1949 none
1950 Example:
1951 """
1952 varlist = vars()
1953 self._recalcazel()
1954 self._add_history("recalc_azel", varlist)
1955 print_log()
1956 return
1957
1958 def __add__(self, other):
1959 varlist = vars()
1960 s = None
1961 if isinstance(other, scantable):
1962 s = scantable(self._math._binaryop(self, other, "ADD"))
1963 elif isinstance(other, float):
1964 s = scantable(self._math._unaryop(self, other, "ADD", False))
1965 else:
1966 raise TypeError("Other input is not a scantable or float value")
1967 s._add_history("operator +", varlist)
1968 print_log()
1969 return s
1970
1971 def __sub__(self, other):
1972 """
1973 implicit on all axes and on Tsys
1974 """
1975 varlist = vars()
1976 s = None
1977 if isinstance(other, scantable):
1978 s = scantable(self._math._binaryop(self, other, "SUB"))
1979 elif isinstance(other, float):
1980 s = scantable(self._math._unaryop(self, other, "SUB", False))
1981 else:
1982 raise TypeError("Other input is not a scantable or float value")
1983 s._add_history("operator -", varlist)
1984 print_log()
1985 return s
1986
1987 def __mul__(self, other):
1988 """
1989 implicit on all axes and on Tsys
1990 """
1991 varlist = vars()
1992 s = None
1993 if isinstance(other, scantable):
1994 s = scantable(self._math._binaryop(self, other, "MUL"))
1995 elif isinstance(other, float):
1996 s = scantable(self._math._unaryop(self, other, "MUL", False))
1997 else:
1998 raise TypeError("Other input is not a scantable or float value")
1999 s._add_history("operator *", varlist)
2000 print_log()
2001 return s
2002
2003
2004 def __div__(self, other):
2005 """
2006 implicit on all axes and on Tsys
2007 """
2008 varlist = vars()
2009 s = None
2010 if isinstance(other, scantable):
2011 s = scantable(self._math._binaryop(self, other, "DIV"))
2012 elif isinstance(other, float):
2013 if other == 0.0:
2014 raise ZeroDivisionError("Dividing by zero is not recommended")
2015 s = scantable(self._math._unaryop(self, other, "DIV", False))
2016 else:
2017 raise TypeError("Other input is not a scantable or float value")
2018 s._add_history("operator /", varlist)
2019 print_log()
2020 return s
2021
2022 def get_fit(self, row=0):
2023 """
2024 Print or return the stored fits for a row in the scantable
2025 Parameters:
2026 row: the row which the fit has been applied to.
2027 """
2028 if row > self.nrow():
2029 return
2030 from asap.asapfit import asapfit
2031 fit = asapfit(self._getfit(row))
2032 if rcParams['verbose']:
2033 #print fit
2034 asaplog.push( '%s' %(fit) )
2035 print_log()
2036 return
2037 else:
2038 return fit.as_dict()
2039
2040 def flag_nans(self):
2041 """
2042 Utility function to flag NaN values in the scantable.
2043 """
2044 import numpy
2045 basesel = self.get_selection()
2046 for i in range(self.nrow()):
2047 sel = selector()+basesel
2048 sel.set_scans(self.getscan(i))
2049 sel.set_beams(self.getbeam(i))
2050 sel.set_ifs(self.getif(i))
2051 sel.set_polarisations(self.getpol(i))
2052 self.set_selection(sel)
2053 nans = numpy.isnan(self._getspectrum(0))
2054 if numpy.any(nans):
2055 bnans = [ bool(v) for v in nans]
2056 self.flag(bnans)
2057 self.set_selection(basesel)
2058
2059
2060 def _add_history(self, funcname, parameters):
2061 if not rcParams['scantable.history']:
2062 return
2063 # create date
2064 sep = "##"
2065 from datetime import datetime
2066 dstr = datetime.now().strftime('%Y/%m/%d %H:%M:%S')
2067 hist = dstr+sep
2068 hist += funcname+sep#cdate+sep
2069 if parameters.has_key('self'): del parameters['self']
2070 for k, v in parameters.iteritems():
2071 if type(v) is dict:
2072 for k2, v2 in v.iteritems():
2073 hist += k2
2074 hist += "="
2075 if isinstance(v2, scantable):
2076 hist += 'scantable'
2077 elif k2 == 'mask':
2078 if isinstance(v2, list) or isinstance(v2, tuple):
2079 hist += str(self._zip_mask(v2))
2080 else:
2081 hist += str(v2)
2082 else:
2083 hist += str(v2)
2084 else:
2085 hist += k
2086 hist += "="
2087 if isinstance(v, scantable):
2088 hist += 'scantable'
2089 elif k == 'mask':
2090 if isinstance(v, list) or isinstance(v, tuple):
2091 hist += str(self._zip_mask(v))
2092 else:
2093 hist += str(v)
2094 else:
2095 hist += str(v)
2096 hist += sep
2097 hist = hist[:-2] # remove trailing '##'
2098 self._addhistory(hist)
2099
2100
2101 def _zip_mask(self, mask):
2102 mask = list(mask)
2103 i = 0
2104 segments = []
2105 while mask[i:].count(1):
2106 i += mask[i:].index(1)
2107 if mask[i:].count(0):
2108 j = i + mask[i:].index(0)
2109 else:
2110 j = len(mask)
2111 segments.append([i, j])
2112 i = j
2113 return segments
2114
2115 def _get_ordinate_label(self):
2116 fu = "("+self.get_fluxunit()+")"
2117 import re
2118 lbl = "Intensity"
2119 if re.match(".K.", fu):
2120 lbl = "Brightness Temperature "+ fu
2121 elif re.match(".Jy.", fu):
2122 lbl = "Flux density "+ fu
2123 return lbl
2124
2125 def _check_ifs(self):
2126 nchans = [self.nchan(i) for i in range(self.nif(-1))]
2127 nchans = filter(lambda t: t > 0, nchans)
2128 return (sum(nchans)/len(nchans) == nchans[0])
2129
2130 def _fill(self, names, unit, average, getpt):
2131 import os
2132 from asap._asap import stfiller
2133 first = True
2134 fullnames = []
2135 for name in names:
2136 name = os.path.expandvars(name)
2137 name = os.path.expanduser(name)
2138 if not os.path.exists(name):
2139 msg = "File '%s' does not exists" % (name)
2140 if rcParams['verbose']:
2141 asaplog.push(msg)
2142 #print asaplog.pop().strip()
2143 print_log( 'ERROR' )
2144 return
2145 raise IOError(msg)
2146 fullnames.append(name)
2147 if average:
2148 asaplog.push('Auto averaging integrations')
2149 stype = int(rcParams['scantable.storage'].lower() == 'disk')
2150 for name in fullnames:
2151 tbl = Scantable(stype)
2152 r = stfiller(tbl)
2153 rx = rcParams['scantable.reference']
2154 r._setreferenceexpr(rx)
2155 msg = "Importing %s..." % (name)
2156 asaplog.push(msg, False)
2157 print_log()
2158 r._open(name, -1, -1, getpt)
2159 r._read()
2160 if average:
2161 tbl = self._math._average((tbl, ), (), 'NONE', 'SCAN')
2162 if not first:
2163 tbl = self._math._merge([self, tbl])
2164 Scantable.__init__(self, tbl)
2165 r._close()
2166 del r, tbl
2167 first = False
2168 if unit is not None:
2169 self.set_fluxunit(unit)
2170 #self.set_freqframe(rcParams['scantable.freqframe'])
2171
2172 def __getitem__(self, key):
2173 if key < 0:
2174 key += self.nrow()
2175 if key >= self.nrow():
2176 raise IndexError("Row index out of range.")
2177 return self._getspectrum(key)
2178
2179 def __setitem__(self, key, value):
2180 if key < 0:
2181 key += self.nrow()
2182 if key >= self.nrow():
2183 raise IndexError("Row index out of range.")
2184 if not hasattr(value, "__len__") or \
2185 len(value) > self.nchan(self.getif(key)):
2186 raise ValueError("Spectrum length doesn't match.")
2187 return self._setspectrum(value, key)
2188
2189 def __len__(self):
2190 return self.nrow()
2191
2192 def __iter__(self):
2193 for i in range(len(self)):
2194 yield self[i]
Note: See TracBrowser for help on using the repository browser.