Context Navigation

source: trunk/python/scantable.py@ 1072

Visit:

Last change on this file since 1072 was 1070, checked in by mar637, 19 years ago
enhancement ticket #35. median scantable; also added get_column
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 56.6 KB

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

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

Download in other formats: