Context Navigation

source: trunk/python/scantable.py @ 1512

Visit:

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

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

Download in other formats: