Context Navigation

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

Visit:

Last change on this file since 1637 was 1637, checked in by WataruKawasaki, 15 years ago

New Development: No

JIRA Issue: Yes (CAS-1434)

Ready to Release: Yes

Interface Changes: No

What Interface Changed:

Test Programs:

Put in Release Notes: No

Module(s):

Description: modified poly_baseline() and auto_poly_baseline()

so that FLAGTRA info is properly used in baseline fitting.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 82.7 KB

Line
1	from asap._asap import Scantable
2	from asap import rcParams
3	from asap import print_log
4	from asap import asaplog
5	from asap import selector
6	from asap import linecatalog
7	from asap import _n_bools, mask_not, mask_and, mask_or
8
9	class 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	varlist = vars()
1521	if mask is None:
1522	mask = [True for i in xrange(self.nchan(-1))]
1523
1524	from asap.asapfitter import fitter
1525	try:
1526	f = fitter()
1527	if uselin:
1528	f.set_function(lpoly=order)
1529	else:
1530	f.set_function(poly=order)
1531
1532	rows = range(self.nrow())
1533	if len(rows) > 0:
1534	self.blpars = []
1535
1536	for r in rows:
1537	# take into account flagtra info (CAS-1434)
1538	flagtra = self._getmask(r)
1539	actualmask = mask[:]
1540	if len(actualmask) == 0:
1541	actualmask = list(flagtra[:])
1542	else:
1543	if len(actualmask) != len(flagtra):
1544	raise RuntimeError, "Mask and flagtra have different length"
1545	else:
1546	for i in range(0, len(actualmask)):
1547	actualmask[i] = actualmask[i] and flagtra[i]
1548	f.set_scan(self, actualmask)
1549	f.x = self._getabcissa(r)
1550	f.y = self._getspectrum(r)
1551	f.data = None
1552	f.fit()
1553	fpar = f.get_parameters()
1554	self.blpars.append(fpar)
1555
1556	#f.set_scan(self, mask)
1557	#s = f.auto_fit(insitu, plot=plot)
1558	## Save parameters of baseline fits as a class attribute.
1559	## NOTICE: It does not reflect changes in scantable!
1560	#self.blpars = f.blpars
1561	s._add_history("poly_baseline", varlist)
1562	print_log()
1563	if insitu: self._assign(s)
1564	else: return s
1565	except RuntimeError:
1566	msg = "The fit failed, possibly because it didn't converge."
1567	if rcParams['verbose']:
1568	#print msg
1569	print_log()
1570	asaplog.push( msg.message )
1571	print_log( 'ERROR' )
1572	return
1573	else:
1574	raise RuntimeError(msg)
1575
1576
1577	def auto_poly_baseline(self, mask=[], edge=(0, 0), order=0,
1578	threshold=3, chan_avg_limit=1, plot=False,
1579	insitu=None):
1580	"""
1581	Return a scan which has been baselined (all rows) by a polynomial.
1582	Spectral lines are detected first using linefinder and masked out
1583	to avoid them affecting the baseline solution.
1584
1585	Parameters:
1586	mask: an optional mask retreived from scantable
1587	edge: an optional number of channel to drop at
1588	the edge of spectrum. If only one value is
1589	specified, the same number will be dropped from
1590	both sides of the spectrum. Default is to keep
1591	all channels. Nested tuples represent individual
1592	edge selection for different IFs (a number of spectral
1593	channels can be different)
1594	order: the order of the polynomial (default is 0)
1595	threshold: the threshold used by line finder. It is better to
1596	keep it large as only strong lines affect the
1597	baseline solution.
1598	chan_avg_limit:
1599	a maximum number of consequtive spectral channels to
1600	average during the search of weak and broad lines.
1601	The default is no averaging (and no search for weak
1602	lines). If such lines can affect the fitted baseline
1603	(e.g. a high order polynomial is fitted), increase this
1604	parameter (usually values up to 8 are reasonable). Most
1605	users of this method should find the default value
1606	sufficient.
1607	plot: plot the fit and the residual. In this each
1608	indivual fit has to be approved, by typing 'y'
1609	or 'n'
1610	insitu: if False a new scantable is returned.
1611	Otherwise, the scaling is done in-situ
1612	The default is taken from .asaprc (False)
1613
1614	Example:
1615	scan2=scan.auto_poly_baseline(order=7)
1616	"""
1617	if insitu is None: insitu = rcParams['insitu']
1618	varlist = vars()
1619	from asap.asapfitter import fitter
1620	from asap.asaplinefind import linefinder
1621	from asap import _is_sequence_or_number as _is_valid
1622
1623	# check whether edge is set up for each IF individually
1624	individualedge = False;
1625	if len(edge) > 1:
1626	if isinstance(edge[0], list) or isinstance(edge[0], tuple):
1627	individualedge = True;
1628
1629	if not _is_valid(edge, int) and not individualedge:
1630	raise ValueError, "Parameter 'edge' has to be an integer or a \
1631	pair of integers specified as a tuple. Nested tuples are allowed \
1632	to make individual selection for different IFs."
1633
1634	curedge = (0, 0)
1635	if individualedge:
1636	for edgepar in edge:
1637	if not _is_valid(edgepar, int):
1638	raise ValueError, "Each element of the 'edge' tuple has \
1639	to be a pair of integers or an integer."
1640	else:
1641	curedge = edge;
1642
1643	# setup fitter
1644	f = fitter()
1645	f.set_function(poly=order)
1646
1647	# setup line finder
1648	fl = linefinder()
1649	fl.set_options(threshold=threshold,avg_limit=chan_avg_limit)
1650
1651	if not insitu:
1652	workscan = self.copy()
1653	else:
1654	workscan = self
1655
1656	fl.set_scan(workscan)
1657
1658	rows = range(workscan.nrow())
1659	# Save parameters of baseline fits & masklists as a class attribute.
1660	# NOTICE: It does not reflect changes in scantable!
1661	if len(rows) > 0:
1662	self.blpars=[]
1663	self.masklists=[]
1664	asaplog.push("Processing:")
1665	for r in rows:
1666	msg = " Scan[%d] Beam[%d] IF[%d] Pol[%d] Cycle[%d]" % \
1667	(workscan.getscan(r), workscan.getbeam(r), workscan.getif(r), \
1668	workscan.getpol(r), workscan.getcycle(r))
1669	asaplog.push(msg, False)
1670
1671	# figure out edge parameter
1672	if individualedge:
1673	if len(edge) >= workscan.getif(r):
1674	raise RuntimeError, "Number of edge elements appear to " \
1675	"be less than the number of IFs"
1676	curedge = edge[workscan.getif(r)]
1677
1678	# take into account flagtra info (CAS-1434)
1679	flagtra = workscan._getmask(r)
1680	actualmask = mask[:]
1681	if len(actualmask) == 0:
1682	actualmask = list(flagtra[:])
1683	else:
1684	if len(actualmask) != len(flagtra):
1685	raise RuntimeError, "Mask and flagtra have different length"
1686	else:
1687	for i in range(0, len(actualmask)):
1688	actualmask[i] = actualmask[i] and flagtra[i]
1689
1690	# setup line finder
1691	fl.find_lines(r, actualmask, curedge)
1692	outmask=fl.get_mask()
1693	f.set_scan(workscan, fl.get_mask())
1694	f.x = workscan._getabcissa(r)
1695	f.y = workscan._getspectrum(r)
1696	f.data = None
1697	f.fit()
1698
1699	# Show mask list
1700	masklist=workscan.get_masklist(fl.get_mask(),row=r)
1701	msg = "mask range: "+str(masklist)
1702	asaplog.push(msg, False)
1703
1704	fpar = f.get_parameters()
1705	if plot:
1706	f.plot(residual=True)
1707	x = raw_input("Accept fit ( [y]/n ): ")
1708	if x.upper() == 'N':
1709	self.blpars.append(None)
1710	self.masklists.append(None)
1711	continue
1712	workscan._setspectrum(f.fitter.getresidual(), r)
1713	self.blpars.append(fpar)
1714	self.masklists.append(masklist)
1715	if plot:
1716	f._p.unmap()
1717	f._p = None
1718	workscan._add_history("auto_poly_baseline", varlist)
1719	if insitu:
1720	self._assign(workscan)
1721	else:
1722	return workscan
1723
1724	def rotate_linpolphase(self, angle):
1725	"""
1726	Rotate the phase of the complex polarization O=Q+iU correlation.
1727	This is always done in situ in the raw data. So if you call this
1728	function more than once then each call rotates the phase further.
1729	Parameters:
1730	angle: The angle (degrees) to rotate (add) by.
1731	Examples:
1732	scan.rotate_linpolphase(2.3)
1733	"""
1734	varlist = vars()
1735	self._math._rotate_linpolphase(self, angle)
1736	self._add_history("rotate_linpolphase", varlist)
1737	print_log()
1738	return
1739
1740
1741	def rotate_xyphase(self, angle):
1742	"""
1743	Rotate the phase of the XY correlation. This is always done in situ
1744	in the data. So if you call this function more than once
1745	then each call rotates the phase further.
1746	Parameters:
1747	angle: The angle (degrees) to rotate (add) by.
1748	Examples:
1749	scan.rotate_xyphase(2.3)
1750	"""
1751	varlist = vars()
1752	self._math._rotate_xyphase(self, angle)
1753	self._add_history("rotate_xyphase", varlist)
1754	print_log()
1755	return
1756
1757	def swap_linears(self):
1758	"""
1759	Swap the linear polarisations XX and YY, or better the first two
1760	polarisations as this also works for ciculars.
1761	"""
1762	varlist = vars()
1763	self._math._swap_linears(self)
1764	self._add_history("swap_linears", varlist)
1765	print_log()
1766	return
1767
1768	def invert_phase(self):
1769	"""
1770	Invert the phase of the complex polarisation
1771	"""
1772	varlist = vars()
1773	self._math._invert_phase(self)
1774	self._add_history("invert_phase", varlist)
1775	print_log()
1776	return
1777
1778	def add(self, offset, insitu=None):
1779	"""
1780	Return a scan where all spectra have the offset added
1781	Parameters:
1782	offset: the offset
1783	insitu: if False a new scantable is returned.
1784	Otherwise, the scaling is done in-situ
1785	The default is taken from .asaprc (False)
1786	"""
1787	if insitu is None: insitu = rcParams['insitu']
1788	self._math._setinsitu(insitu)
1789	varlist = vars()
1790	s = scantable(self._math._unaryop(self, offset, "ADD", False))
1791	s._add_history("add", varlist)
1792	print_log()
1793	if insitu:
1794	self._assign(s)
1795	else:
1796	return s
1797
1798	def scale(self, factor, tsys=True, insitu=None):
1799	"""
1800	Return a scan where all spectra are scaled by the give 'factor'
1801	Parameters:
1802	factor: the scaling factor
1803	insitu: if False a new scantable is returned.
1804	Otherwise, the scaling is done in-situ
1805	The default is taken from .asaprc (False)
1806	tsys: if True (default) then apply the operation to Tsys
1807	as well as the data
1808	"""
1809	if insitu is None: insitu = rcParams['insitu']
1810	self._math._setinsitu(insitu)
1811	varlist = vars()
1812	s = scantable(self._math._unaryop(self, factor, "MUL", tsys))
1813	s._add_history("scale", varlist)
1814	print_log()
1815	if insitu:
1816	self._assign(s)
1817	else:
1818	return s
1819
1820	def set_sourcetype(self, match, matchtype="pattern",
1821	sourcetype="reference"):
1822	"""
1823	Set the type of the source to be an source or reference scan
1824	using the provided pattern:
1825	Parameters:
1826	match: a Unix style pattern, regular expression or selector
1827	matchtype: 'pattern' (default) UNIX style pattern or
1828	'regex' regular expression
1829	sourcetype: the type of the source to use (source/reference)
1830	"""
1831	varlist = vars()
1832	basesel = self.get_selection()
1833	stype = -1
1834	if sourcetype.lower().startswith("r"):
1835	stype = 1
1836	elif sourcetype.lower().startswith("s"):
1837	stype = 0
1838	else:
1839	raise ValueError("Illegal sourcetype use s(ource) or r(eference)")
1840	if matchtype.lower().startswith("p"):
1841	matchtype = "pattern"
1842	elif matchtype.lower().startswith("r"):
1843	matchtype = "regex"
1844	else:
1845	raise ValueError("Illegal matchtype, use p(attern) or r(egex)")
1846	sel = selector()
1847	if isinstance(match, selector):
1848	sel = match
1849	else:
1850	sel.set_query("SRCNAME == %s('%s')" % (matchtype, match))
1851	self.set_selection(basesel+sel)
1852	self._setsourcetype(stype)
1853	self.set_selection(basesel)
1854	s._add_history("set_sourcetype", varlist)
1855
1856	def auto_quotient(self, preserve=True, mode='paired', verify=False):
1857	"""
1858	This function allows to build quotients automatically.
1859	It assumes the observation to have the same number of
1860	"ons" and "offs"
1861	Parameters:
1862	preserve: you can preserve (default) the continuum or
1863	remove it. The equations used are
1864	preserve: Output = Toff * (on/off) - Toff
1865	remove: Output = Toff * (on/off) - Ton
1866	mode: the on/off detection mode
1867	'paired' (default)
1868	identifies 'off' scans by the
1869	trailing '_R' (Mopra/Parkes) or
1870	'_e'/'_w' (Tid) and matches
1871	on/off pairs from the observing pattern
1872	'time'
1873	finds the closest off in time
1874
1875	"""
1876	modes = ["time", "paired"]
1877	if not mode in modes:
1878	msg = "please provide valid mode. Valid modes are %s" % (modes)
1879	raise ValueError(msg)
1880	varlist = vars()
1881	s = None
1882	if mode.lower() == "paired":
1883	basesel = self.get_selection()
1884	sel = selector()+basesel
1885	sel.set_query("SRCTYPE==1")
1886	self.set_selection(sel)
1887	offs = self.copy()
1888	sel.set_query("SRCTYPE==0")
1889	self.set_selection(sel)
1890	ons = self.copy()
1891	s = scantable(self._math._quotient(ons, offs, preserve))
1892	self.set_selection(basesel)
1893	elif mode.lower() == "time":
1894	s = scantable(self._math._auto_quotient(self, mode, preserve))
1895	s._add_history("auto_quotient", varlist)
1896	print_log()
1897	return s
1898
1899	def mx_quotient(self, mask = None, weight='median', preserve=True):
1900	"""
1901	Form a quotient using "off" beams when observing in "MX" mode.
1902	Parameters:
1903	mask: an optional mask to be used when weight == 'stddev'
1904	weight: How to average the off beams. Default is 'median'.
1905	preserve: you can preserve (default) the continuum or
1906	remove it. The equations used are
1907	preserve: Output = Toff * (on/off) - Toff
1908	remove: Output = Toff * (on/off) - Ton
1909	"""
1910	if mask is None: mask = ()
1911	varlist = vars()
1912	on = scantable(self._math._mx_extract(self, 'on'))
1913	preoff = scantable(self._math._mx_extract(self, 'off'))
1914	off = preoff.average_time(mask=mask, weight=weight, scanav=False)
1915	from asapmath import quotient
1916	q = quotient(on, off, preserve)
1917	q._add_history("mx_quotient", varlist)
1918	print_log()
1919	return q
1920
1921	def freq_switch(self, insitu=None):
1922	"""
1923	Apply frequency switching to the data.
1924	Parameters:
1925	insitu: if False a new scantable is returned.
1926	Otherwise, the swictching is done in-situ
1927	The default is taken from .asaprc (False)
1928	Example:
1929	none
1930	"""
1931	if insitu is None: insitu = rcParams['insitu']
1932	self._math._setinsitu(insitu)
1933	varlist = vars()
1934	s = scantable(self._math._freqswitch(self))
1935	s._add_history("freq_switch", varlist)
1936	print_log()
1937	if insitu: self._assign(s)
1938	else: return s
1939
1940	def recalc_azel(self):
1941	"""
1942	Recalculate the azimuth and elevation for each position.
1943	Parameters:
1944	none
1945	Example:
1946	"""
1947	varlist = vars()
1948	self._recalcazel()
1949	self._add_history("recalc_azel", varlist)
1950	print_log()
1951	return
1952
1953	def __add__(self, other):
1954	varlist = vars()
1955	s = None
1956	if isinstance(other, scantable):
1957	s = scantable(self._math._binaryop(self, other, "ADD"))
1958	elif isinstance(other, float):
1959	s = scantable(self._math._unaryop(self, other, "ADD", False))
1960	else:
1961	raise TypeError("Other input is not a scantable or float value")
1962	s._add_history("operator +", varlist)
1963	print_log()
1964	return s
1965
1966	def __sub__(self, other):
1967	"""
1968	implicit on all axes and on Tsys
1969	"""
1970	varlist = vars()
1971	s = None
1972	if isinstance(other, scantable):
1973	s = scantable(self._math._binaryop(self, other, "SUB"))
1974	elif isinstance(other, float):
1975	s = scantable(self._math._unaryop(self, other, "SUB", False))
1976	else:
1977	raise TypeError("Other input is not a scantable or float value")
1978	s._add_history("operator -", varlist)
1979	print_log()
1980	return s
1981
1982	def __mul__(self, other):
1983	"""
1984	implicit on all axes and on Tsys
1985	"""
1986	varlist = vars()
1987	s = None
1988	if isinstance(other, scantable):
1989	s = scantable(self._math._binaryop(self, other, "MUL"))
1990	elif isinstance(other, float):
1991	s = scantable(self._math._unaryop(self, other, "MUL", False))
1992	else:
1993	raise TypeError("Other input is not a scantable or float value")
1994	s._add_history("operator *", varlist)
1995	print_log()
1996	return s
1997
1998
1999	def __div__(self, other):
2000	"""
2001	implicit on all axes and on Tsys
2002	"""
2003	varlist = vars()
2004	s = None
2005	if isinstance(other, scantable):
2006	s = scantable(self._math._binaryop(self, other, "DIV"))
2007	elif isinstance(other, float):
2008	if other == 0.0:
2009	raise ZeroDivisionError("Dividing by zero is not recommended")
2010	s = scantable(self._math._unaryop(self, other, "DIV", False))
2011	else:
2012	raise TypeError("Other input is not a scantable or float value")
2013	s._add_history("operator /", varlist)
2014	print_log()
2015	return s
2016
2017	def get_fit(self, row=0):
2018	"""
2019	Print or return the stored fits for a row in the scantable
2020	Parameters:
2021	row: the row which the fit has been applied to.
2022	"""
2023	if row > self.nrow():
2024	return
2025	from asap.asapfit import asapfit
2026	fit = asapfit(self._getfit(row))
2027	if rcParams['verbose']:
2028	#print fit
2029	asaplog.push( '%s' %(fit) )
2030	print_log()
2031	return
2032	else:
2033	return fit.as_dict()
2034
2035	def flag_nans(self):
2036	"""
2037	Utility function to flag NaN values in the scantable.
2038	"""
2039	import numpy
2040	basesel = self.get_selection()
2041	for i in range(self.nrow()):
2042	sel = selector()+basesel
2043	sel.set_scans(self.getscan(i))
2044	sel.set_beams(self.getbeam(i))
2045	sel.set_ifs(self.getif(i))
2046	sel.set_polarisations(self.getpol(i))
2047	self.set_selection(sel)
2048	nans = numpy.isnan(self._getspectrum(0))
2049	if numpy.any(nans):
2050	bnans = [ bool(v) for v in nans]
2051	self.flag(bnans)
2052	self.set_selection(basesel)
2053
2054
2055	def _add_history(self, funcname, parameters):
2056	if not rcParams['scantable.history']:
2057	return
2058	# create date
2059	sep = "##"
2060	from datetime import datetime
2061	dstr = datetime.now().strftime('%Y/%m/%d %H:%M:%S')
2062	hist = dstr+sep
2063	hist += funcname+sep#cdate+sep
2064	if parameters.has_key('self'): del parameters['self']
2065	for k, v in parameters.iteritems():
2066	if type(v) is dict:
2067	for k2, v2 in v.iteritems():
2068	hist += k2
2069	hist += "="
2070	if isinstance(v2, scantable):
2071	hist += 'scantable'
2072	elif k2 == 'mask':
2073	if isinstance(v2, list) or isinstance(v2, tuple):
2074	hist += str(self._zip_mask(v2))
2075	else:
2076	hist += str(v2)
2077	else:
2078	hist += str(v2)
2079	else:
2080	hist += k
2081	hist += "="
2082	if isinstance(v, scantable):
2083	hist += 'scantable'
2084	elif k == 'mask':
2085	if isinstance(v, list) or isinstance(v, tuple):
2086	hist += str(self._zip_mask(v))
2087	else:
2088	hist += str(v)
2089	else:
2090	hist += str(v)
2091	hist += sep
2092	hist = hist[:-2] # remove trailing '##'
2093	self._addhistory(hist)
2094
2095
2096	def _zip_mask(self, mask):
2097	mask = list(mask)
2098	i = 0
2099	segments = []
2100	while mask[i:].count(1):
2101	i += mask[i:].index(1)
2102	if mask[i:].count(0):
2103	j = i + mask[i:].index(0)
2104	else:
2105	j = len(mask)
2106	segments.append([i, j])
2107	i = j
2108	return segments
2109
2110	def _get_ordinate_label(self):
2111	fu = "("+self.get_fluxunit()+")"
2112	import re
2113	lbl = "Intensity"
2114	if re.match(".K.", fu):
2115	lbl = "Brightness Temperature "+ fu
2116	elif re.match(".Jy.", fu):
2117	lbl = "Flux density "+ fu
2118	return lbl
2119
2120	def _check_ifs(self):
2121	nchans = [self.nchan(i) for i in range(self.nif(-1))]
2122	nchans = filter(lambda t: t > 0, nchans)
2123	return (sum(nchans)/len(nchans) == nchans[0])
2124
2125	def _fill(self, names, unit, average, getpt):
2126	import os
2127	from asap._asap import stfiller
2128	first = True
2129	fullnames = []
2130	for name in names:
2131	name = os.path.expandvars(name)
2132	name = os.path.expanduser(name)
2133	if not os.path.exists(name):
2134	msg = "File '%s' does not exists" % (name)
2135	if rcParams['verbose']:
2136	asaplog.push(msg)
2137	#print asaplog.pop().strip()
2138	print_log( 'ERROR' )
2139	return
2140	raise IOError(msg)
2141	fullnames.append(name)
2142	if average:
2143	asaplog.push('Auto averaging integrations')
2144	stype = int(rcParams['scantable.storage'].lower() == 'disk')
2145	for name in fullnames:
2146	tbl = Scantable(stype)
2147	r = stfiller(tbl)
2148	rx = rcParams['scantable.reference']
2149	r._setreferenceexpr(rx)
2150	msg = "Importing %s..." % (name)
2151	asaplog.push(msg, False)
2152	print_log()
2153	r._open(name, -1, -1, getpt)
2154	r._read()
2155	if average:
2156	tbl = self._math._average((tbl, ), (), 'NONE', 'SCAN')
2157	if not first:
2158	tbl = self._math._merge([self, tbl])
2159	Scantable.__init__(self, tbl)
2160	r._close()
2161	del r, tbl
2162	first = False
2163	if unit is not None:
2164	self.set_fluxunit(unit)
2165	#self.set_freqframe(rcParams['scantable.freqframe'])
2166
2167	def __getitem__(self, key):
2168	if key < 0:
2169	key += self.nrow()
2170	if key >= self.nrow():
2171	raise IndexError("Row index out of range.")
2172	return self._getspectrum(key)
2173
2174	def __setitem__(self, key, value):
2175	if key < 0:
2176	key += self.nrow()
2177	if key >= self.nrow():
2178	raise IndexError("Row index out of range.")
2179	if not hasattr(value, "__len__") or \
2180	len(value) > self.nchan(self.getif(key)):
2181	raise ValueError("Spectrum length doesn't match.")
2182	return self._setspectrum(value, key)
2183
2184	def __len__(self):
2185	return self.nrow()
2186
2187	def __iter__(self):
2188	for i in range(len(self)):
2189	yield self[i]

Note: See TracBrowser for help on using the repository browser.

Download in other formats: