Context Navigation

source: trunk/python/scantable.py@ 1027

Visit:

Last change on this file since 1027 was 1024, checked in by mar637, 19 years ago
Fixed create_mask to use start and end point. Added example
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 55.3 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
	379
[407]	380	def get_time(self, row=-1):
[113]	381	"""
	382	Get a list of time stamps for the observations.
[181]	383	Return a string for each integration in the scantable.
[113]	384	Parameters:
[407]	385	row: row no of integration. Default -1 return all rows
[113]	386	Example:
	387	none
	388	"""
	389	out = []
[407]	390	if row == -1:
	391	for i in range(self.nrow()):
	392	out.append(self._gettime(i))
	393	return out
	394	else:
	395	if row < self.nrow():
	396	return self._gettime(row)
[102]	397
[714]	398	def get_sourcename(self, row=-1):
	399	"""
[794]	400	Get a list source names for the observations.
[714]	401	Return a string for each integration in the scantable.
	402	Parameters:
	403	row: row no of integration. Default -1 return all rows
	404	Example:
	405	none
	406	"""
	407	out = []
	408	if row == -1:
	409	return [self._getsourcename(i) for i in range(self.nrow())]
	410	else:
	411	if 0 <= row < self.nrow():
	412	return self._getsourcename(row)
	413
[794]	414	def get_elevation(self, row=-1):
	415	"""
	416	Get a list of elevations for the observations.
	417	Return a float for each integration in the scantable.
	418	Parameters:
	419	row: row no of integration. Default -1 return all rows
	420	Example:
	421	none
	422	"""
	423	out = []
	424	if row == -1:
	425	return [self._getelevation(i) for i in range(self.nrow())]
	426	else:
	427	if 0 <= row < self.nrow():
	428	return self._getelevation(row)
	429
	430	def get_azimuth(self, row=-1):
	431	"""
	432	Get a list of azimuths for the observations.
	433	Return a float for each integration in the scantable.
	434	Parameters:
	435	row: row no of integration. Default -1 return all rows
	436	Example:
	437	none
	438	"""
	439	out = []
	440	if row == -1:
	441	return [self._getazimuth(i) for i in range(self.nrow())]
	442	else:
	443	if 0 <= row < self.nrow():
	444	return self._getazimuth(row)
	445
	446	def get_parangle(self, row=-1):
	447	"""
	448	Get a list of parallactic angles for the observations.
	449	Return a float for each integration in the scantable.
	450	Parameters:
	451	row: row no of integration. Default -1 return all rows
	452	Example:
	453	none
	454	"""
	455	out = []
	456	if row == -1:
	457	return [self._getparangle(i) for i in range(self.nrow())]
	458	else:
	459	if 0 <= row < self.nrow():
	460	return self._getparangle(row)
	461
[102]	462	def set_unit(self, unit='channel'):
	463	"""
	464	Set the unit for all following operations on this scantable
	465	Parameters:
	466	unit: optional unit, default is 'channel'
[113]	467	one of '*Hz','km/s','channel', ''
[102]	468	"""
[484]	469	varlist = vars()
[113]	470	if unit in ['','pixel', 'channel']:
	471	unit = ''
	472	inf = list(self._getcoordinfo())
	473	inf[0] = unit
	474	self._setcoordinfo(inf)
[484]	475	self._add_history("set_unit",varlist)
[113]	476
[484]	477	def set_instrument(self, instr):
[358]	478	"""
	479	Set the instrument for subsequent processing
	480	Parameters:
[710]	481	instr: Select from 'ATPKSMB', 'ATPKSHOH', 'ATMOPRA',
[407]	482	'DSS-43' (Tid), 'CEDUNA', and 'HOBART'
[358]	483	"""
	484	self._setInstrument(instr)
[484]	485	self._add_history("set_instument",vars())
[718]	486	print_log()
[358]	487
[276]	488	def set_doppler(self, doppler='RADIO'):
	489	"""
	490	Set the doppler for all following operations on this scantable.
	491	Parameters:
	492	doppler: One of 'RADIO', 'OPTICAL', 'Z', 'BETA', 'GAMMA'
	493	"""
[484]	494	varlist = vars()
[276]	495	inf = list(self._getcoordinfo())
	496	inf[2] = doppler
	497	self._setcoordinfo(inf)
[484]	498	self._add_history("set_doppler",vars())
[718]	499	print_log()
[710]	500
[226]	501	def set_freqframe(self, frame=None):
[113]	502	"""
	503	Set the frame type of the Spectral Axis.
	504	Parameters:
[591]	505	frame: an optional frame type, default 'LSRK'. Valid frames are:
	506	'REST','TOPO','LSRD','LSRK','BARY',
	507	'GEO','GALACTO','LGROUP','CMB'
[113]	508	Examples:
	509	scan.set_freqframe('BARY')
	510	"""
[484]	511	if frame is None: frame = rcParams['scantable.freqframe']
	512	varlist = vars()
[113]	513	valid = ['REST','TOPO','LSRD','LSRK','BARY', \
	514	'GEO','GALACTO','LGROUP','CMB']
[591]	515
[989]	516	if frame in valid:
[113]	517	inf = list(self._getcoordinfo())
	518	inf[1] = frame
	519	self._setcoordinfo(inf)
[484]	520	self._add_history("set_freqframe",varlist)
[102]	521	else:
[718]	522	msg = "Please specify a valid freq type. Valid types are:\n",valid
	523	if rcParams['verbose']:
	524	print msg
	525	else:
	526	raise TypeError(msg)
	527	print_log()
[710]	528
[989]	529	def set_dirframe(self, frame=""):
	530	"""
	531	Set the frame type of the Direction on the sky.
	532	Parameters:
	533	frame: an optional frame type, default ''. Valid frames are:
	534	'J2000', 'B1950', 'GALACTIC'
	535	Examples:
	536	scan.set_dirframe('GALACTIC')
	537	"""
	538	varlist = vars()
	539	try:
	540	Scantable.set_dirframe(self, frame)
	541	except RuntimeError,msg:
	542	if rcParams['verbose']:
	543	print msg
	544	else:
	545	raise
	546	self._add_history("set_dirframe",varlist)
	547
[113]	548	def get_unit(self):
	549	"""
	550	Get the default unit set in this scantable
	551	Parameters:
	552	Returns:
	553	A unit string
	554	"""
	555	inf = self._getcoordinfo()
	556	unit = inf[0]
	557	if unit == '': unit = 'channel'
	558	return unit
[102]	559
[158]	560	def get_abcissa(self, rowno=0):
[102]	561	"""
[158]	562	Get the abcissa in the current coordinate setup for the currently
[113]	563	selected Beam/IF/Pol
	564	Parameters:
[226]	565	rowno: an optional row number in the scantable. Default is the
	566	first row, i.e. rowno=0
[113]	567	Returns:
[407]	568	The abcissa values and it's format string (as a dictionary)
[113]	569	"""
[256]	570	abc = self._getabcissa(rowno)
[710]	571	lbl = self._getabcissalabel(rowno)
[718]	572	print_log()
[158]	573	return abc, lbl
[113]	574
[1001]	575	def flag(self, mask=[]):
	576	"""
	577	Flag the selected data using an optional channel mask.
	578	Parameters:
	579	mask: an optional channel mask, created with create_mask. Default
	580	(no mask) is all channels.
	581	"""
	582	varlist = vars()
	583	try:
	584	self._flag(mask)
	585	except RuntimeError,msg:
	586	if rcParams['verbose']:
	587	print msg
	588	return
	589	else: raise
	590	self._add_history("flag", varlist)
	591
	592
[113]	593	def create_mask(self, args, *kwargs):
	594	"""
[102]	595	Compute and return a mask based on [min,max] windows.
[189]	596	The specified windows are to be INCLUDED, when the mask is
[113]	597	applied.
[102]	598	Parameters:
	599	[min,max],[min2,max2],...
[1024]	600	Pairs of start/end points (inclusive)specifying the regions
[102]	601	to be masked
[189]	602	invert: optional argument. If specified as True,
	603	return an inverted mask, i.e. the regions
	604	specified are EXCLUDED
[513]	605	row: create the mask using the specified row for
	606	unit conversions, default is row=0
	607	only necessary if frequency varies over rows.
[102]	608	Example:
[113]	609	scan.set_unit('channel')
	610	a)
[1024]	611	msk = scan.create_mask([400,500],[800,900])
[189]	612	# masks everything outside 400 and 500
[113]	613	# and 800 and 900 in the unit 'channel'
	614
	615	b)
[1024]	616	msk = scan.create_mask([400,500],[800,900], invert=True)
[189]	617	# masks the regions between 400 and 500
[113]	618	# and 800 and 900 in the unit 'channel'
[1024]	619	c)
	620	mask only channel 400
	621	msk = scan.create_mask([400,400])
[102]	622	"""
[513]	623	row = 0
	624	if kwargs.has_key("row"):
	625	row = kwargs.get("row")
	626	data = self._getabcissa(row)
[113]	627	u = self._getcoordinfo()[0]
[718]	628	if rcParams['verbose']:
[113]	629	if u == "": u = "channel"
[718]	630	from asap import asaplog
	631	msg = "The current mask window unit is %s" % u
[914]	632	if not self._check_ifs():
[876]	633	msg += "\nThis mask is only valid for IF=%d" % (self.getif(i))
[718]	634	asaplog.push(msg)
[102]	635	n = self.nchan()
[189]	636	msk = zeros(n)
[710]	637	# test if args is a 'list' or a 'normal *args - UGLY!!!
	638
	639	ws = (isinstance(args[-1][-1],int) or isinstance(args[-1][-1],float)) and args or args[0]
	640	for window in ws:
[102]	641	if (len(window) != 2 or window[0] > window[1] ):
[718]	642	raise TypeError("A window needs to be defined as [min,max]")
[102]	643	for i in range(n):
[1024]	644	if data[i] >= window[0] and data[i] <= window[1]:
[189]	645	msk[i] = 1
[113]	646	if kwargs.has_key('invert'):
	647	if kwargs.get('invert'):
	648	from numarray import logical_not
[710]	649	msk = logical_not(msk)
[718]	650	print_log()
[102]	651	return msk
[710]	652
[256]	653	def get_restfreqs(self):
	654	"""
	655	Get the restfrequency(s) stored in this scantable.
	656	The return value(s) are always of unit 'Hz'
	657	Parameters:
	658	none
	659	Returns:
	660	a list of doubles
	661	"""
	662	return list(self._getrestfreqs())
[102]	663
[402]	664
[931]	665	def set_restfreqs(self, freqs=None, unit='Hz'):
	666	"""
	667	Set or replace the restfrequency specified and
	668	If the 'freqs' argument holds a scalar,
	669	then that rest frequency will be applied to all the selected
	670	data. If the 'freqs' argument holds
	671	a vector, then it MUST be of equal or smaller length than
	672	the number of IFs (and the available restfrequencies will be
	673	replaced by this vector). In this case, all data have
	674	the restfrequency set per IF according
	675	to the corresponding value you give in the 'freqs' vector.
	676	E.g. 'freqs=[1e9,2e9]' would mean IF 0 gets restfreq 1e9 and
	677	IF 1 gets restfreq 2e9.
	678	You can also specify the frequencies via known line names
	679	from the built-in Lovas table.
	680	Parameters:
	681	freqs: list of rest frequency values or string idenitfiers
	682	unit: unit for rest frequency (default 'Hz')
[402]	683
[931]	684	Example:
	685	# set the given restfrequency for the whole table
	686	scan.set_restfreqs(freqs=1.4e9)
	687	# If thee number of IFs in the data is >= 2 the IF0 gets the first
	688	# value IF1 the second...
	689	scan.set_restfreqs(freqs=[1.4e9,1.67e9])
	690	#set the given restfrequency for the whole table (by name)
	691	scan.set_restfreqs(freqs="OH1667")
[391]	692
[931]	693	Note:
	694	To do more sophisticate Restfrequency setting, e.g. on a
	695	source and IF basis, use scantable.set_selection() before using
	696	this function.
	697	# provide your scantable is call scan
	698	selection = selector()
	699	selection.set_name("ORION*")
	700	selection.set_ifs([1])
	701	scan.set_selection(selection)
	702	scan.set_restfreqs(freqs=86.6e9)
	703
	704	"""
	705	varlist = vars()
	706
	707	t = type(freqs)
	708	if isinstance(freqs, int) or isinstance(freqs,float):
	709	self._setrestfreqs(freqs, unit)
	710	elif isinstance(freqs, list) or isinstance(freqs,tuple):
	711	if isinstance(freqs[-1], int) or isinstance(freqs[-1],float):
	712	sel = selector()
	713	savesel = self._getselection()
	714	for i in xrange(len(freqs)):
[946]	715	sel.set_ifs([i])
[931]	716	self._setselection(sel)
	717	self._setrestfreqs(freqs[i], unit)
	718	self._setselection(savesel)
	719	elif isinstance(freqs[-1], str):
	720	# not yet implemented
	721	pass
	722	else:
	723	return
	724	self._add_history("set_restfreqs", varlist)
	725
	726
	727
[484]	728	def history(self):
	729	hist = list(self._gethistory())
[794]	730	out = "-"*80
[484]	731	for h in hist:
[489]	732	if h.startswith("---"):
[794]	733	out += "\n"+h
[489]	734	else:
	735	items = h.split("##")
	736	date = items[0]
	737	func = items[1]
	738	items = items[2:]
[794]	739	out += "\n"+date+"\n"
	740	out += "Function: %s\n Parameters:" % (func)
[489]	741	for i in items:
	742	s = i.split("=")
[794]	743	out += "\n %s = %s" % (s[0],s[1])
	744	out += "\n"+"-"*80
	745	try:
	746	from IPython.genutils import page as pager
	747	except ImportError:
	748	from pydoc import pager
	749	pager(out)
[484]	750	return
	751
[513]	752	#
	753	# Maths business
	754	#
	755
[931]	756	def average_time(self, mask=None, scanav=False, weight='tint', align=False):
[513]	757	"""
	758	Return the (time) average of a scan, or apply it 'insitu'.
	759	Note:
	760	in channels only
	761	The cursor of the output scan is set to 0.
	762	Parameters:
	763	one scan or comma separated scans
	764	mask: an optional mask (only used for 'var' and 'tsys'
	765	weighting)
[558]	766	scanav: True averages each scan separately
	767	False (default) averages all scans together,
[524]	768	weight: Weighting scheme. 'none', 'var' (1/var(spec)
[535]	769	weighted), 'tsys' (1/Tsys**2 weighted), 'tint'
	770	(integration time weighted) or 'tintsys' (Tint/Tsys**2).
	771	The default is 'tint'
[931]	772	align: align the spectra in velocity before averaging. It takes
	773	the time of the first spectrum as reference time.
[513]	774	Example:
	775	# time average the scantable without using a mask
[710]	776	newscan = scan.average_time()
[513]	777	"""
	778	varlist = vars()
[976]	779	if weight is None: weight = 'TINT'
[513]	780	if mask is None: mask = ()
[876]	781	if scanav:
[981]	782	scanav = "SCAN"
[876]	783	else:
[981]	784	scanav = "NONE"
	785	scan = (self,)
[989]	786	try:
	787	if align:
	788	scan = (self.freq_align(insitu=False),)
	789	s = scantable(self._math._average(scan, mask, weight.upper(),
	790	scanav))
	791	except RuntimeError,msg:
	792	if rcParams['verbose']:
	793	print msg
	794	return
	795	else: raise
[513]	796	s._add_history("average_time",varlist)
[718]	797	print_log()
[513]	798	return s
[710]	799
[876]	800	def convert_flux(self, jyperk=None, eta=None, d=None, insitu=None):
[513]	801	"""
	802	Return a scan where all spectra are converted to either
	803	Jansky or Kelvin depending upon the flux units of the scan table.
	804	By default the function tries to look the values up internally.
	805	If it can't find them (or if you want to over-ride), you must
	806	specify EITHER jyperk OR eta (and D which it will try to look up
	807	also if you don't set it). jyperk takes precedence if you set both.
	808	Parameters:
	809	jyperk: the Jy / K conversion factor
	810	eta: the aperture efficiency
	811	d: the geomtric diameter (metres)
	812	insitu: if False a new scantable is returned.
	813	Otherwise, the scaling is done in-situ
	814	The default is taken from .asaprc (False)
	815	allaxes: if True apply to all spectra. Otherwise
	816	apply only to the selected (beam/pol/if)spectra only
	817	The default is taken from .asaprc (True if none)
	818	"""
	819	if insitu is None: insitu = rcParams['insitu']
[876]	820	self._math._setinsitu(insitu)
[513]	821	varlist = vars()
	822	if jyperk is None: jyperk = -1.0
	823	if d is None: d = -1.0
	824	if eta is None: eta = -1.0
[876]	825	s = scantable(self._math._convertflux(self, d, eta, jyperk))
	826	s._add_history("convert_flux", varlist)
	827	print_log()
	828	if insitu: self._assign(s)
	829	else: return s
[513]	830
[876]	831	def gain_el(self, poly=None, filename="", method="linear", insitu=None):
[513]	832	"""
	833	Return a scan after applying a gain-elevation correction.
	834	The correction can be made via either a polynomial or a
	835	table-based interpolation (and extrapolation if necessary).
	836	You specify polynomial coefficients, an ascii table or neither.
	837	If you specify neither, then a polynomial correction will be made
	838	with built in coefficients known for certain telescopes (an error
	839	will occur if the instrument is not known).
	840	The data and Tsys are divided by the scaling factors.
	841	Parameters:
	842	poly: Polynomial coefficients (default None) to compute a
	843	gain-elevation correction as a function of
	844	elevation (in degrees).
	845	filename: The name of an ascii file holding correction factors.
	846	The first row of the ascii file must give the column
	847	names and these MUST include columns
	848	"ELEVATION" (degrees) and "FACTOR" (multiply data
	849	by this) somewhere.
	850	The second row must give the data type of the
	851	column. Use 'R' for Real and 'I' for Integer.
	852	An example file would be
	853	(actual factors are arbitrary) :
	854
	855	TIME ELEVATION FACTOR
	856	R R R
	857	0.1 0 0.8
	858	0.2 20 0.85
	859	0.3 40 0.9
	860	0.4 60 0.85
	861	0.5 80 0.8
	862	0.6 90 0.75
	863	method: Interpolation method when correcting from a table.
	864	Values are "nearest", "linear" (default), "cubic"
	865	and "spline"
	866	insitu: if False a new scantable is returned.
	867	Otherwise, the scaling is done in-situ
	868	The default is taken from .asaprc (False)
	869	"""
	870
	871	if insitu is None: insitu = rcParams['insitu']
[876]	872	self._math._setinsitu(insitu)
[513]	873	varlist = vars()
	874	if poly is None:
	875	poly = ()
	876	from os.path import expandvars
	877	filename = expandvars(filename)
[876]	878	s = scantable(self._math._gainel(self, poly, filename, method))
	879	s._add_history("gain_el", varlist)
	880	print_log()
	881	if insitu: self._assign(s)
	882	else: return s
[710]	883
[931]	884	def freq_align(self, reftime=None, method='cubic', insitu=None):
[513]	885	"""
	886	Return a scan where all rows have been aligned in frequency/velocity.
	887	The alignment frequency frame (e.g. LSRK) is that set by function
	888	set_freqframe.
	889	Parameters:
	890	reftime: reference time to align at. By default, the time of
	891	the first row of data is used.
	892	method: Interpolation method for regridding the spectra.
	893	Choose from "nearest", "linear", "cubic" (default)
	894	and "spline"
	895	insitu: if False a new scantable is returned.
	896	Otherwise, the scaling is done in-situ
	897	The default is taken from .asaprc (False)
	898	"""
[931]	899	if insitu is None: insitu = rcParams["insitu"]
[876]	900	self._math._setinsitu(insitu)
[513]	901	varlist = vars()
[931]	902	if reftime is None: reftime = ""
	903	s = scantable(self._math._freq_align(self, reftime, method))
[876]	904	s._add_history("freq_align", varlist)
	905	print_log()
	906	if insitu: self._assign(s)
	907	else: return s
[513]	908
[876]	909	def opacity(self, tau, insitu=None):
[513]	910	"""
	911	Apply an opacity correction. The data
	912	and Tsys are multiplied by the correction factor.
	913	Parameters:
	914	tau: Opacity from which the correction factor is
	915	exp(tau*ZD)
	916	where ZD is the zenith-distance
	917	insitu: if False a new scantable is returned.
	918	Otherwise, the scaling is done in-situ
	919	The default is taken from .asaprc (False)
	920	"""
	921	if insitu is None: insitu = rcParams['insitu']
[876]	922	self._math._setinsitu(insitu)
[513]	923	varlist = vars()
[876]	924	s = scantable(self._math._opacity(self, tau))
	925	s._add_history("opacity", varlist)
	926	print_log()
	927	if insitu: self._assign(s)
	928	else: return s
[513]	929
	930	def bin(self, width=5, insitu=None):
	931	"""
	932	Return a scan where all spectra have been binned up.
	933	width: The bin width (default=5) in pixels
	934	insitu: if False a new scantable is returned.
	935	Otherwise, the scaling is done in-situ
	936	The default is taken from .asaprc (False)
	937	"""
	938	if insitu is None: insitu = rcParams['insitu']
[876]	939	self._math._setinsitu(insitu)
[513]	940	varlist = vars()
[876]	941	s = scantable(self._math._bin(self, width))
	942	s._add_history("bin",varlist)
	943	print_log()
	944	if insitu: self._assign(s)
	945	else: return s
[513]	946
[710]	947
[513]	948	def resample(self, width=5, method='cubic', insitu=None):
	949	"""
	950	Return a scan where all spectra have been binned up
	951	width: The bin width (default=5) in pixels
	952	method: Interpolation method when correcting from a table.
	953	Values are "nearest", "linear", "cubic" (default)
	954	and "spline"
	955	insitu: if False a new scantable is returned.
	956	Otherwise, the scaling is done in-situ
	957	The default is taken from .asaprc (False)
	958	"""
	959	if insitu is None: insitu = rcParams['insitu']
[876]	960	self._math._setinsitu(insitu)
[513]	961	varlist = vars()
[876]	962	s = scantable(self._math._resample(self, method, width))
	963	s._add_history("resample",varlist)
	964	print_log()
	965	if insitu: self._assign(s)
	966	else: return s
[513]	967
	968
[946]	969	def average_pol(self, mask=None, weight='none'):
	970	"""
	971	Average the Polarisations together.
	972	Parameters:
	973	mask: An optional mask defining the region, where the
	974	averaging will be applied. The output will have all
	975	specified points masked.
	976	weight: Weighting scheme. 'none' (default), 'var' (1/var(spec)
	977	weighted), or 'tsys' (1/Tsys**2 weighted)
	978	"""
	979	varlist = vars()
	980	if mask is None:
	981	mask = ()
[1010]	982	s = scantable(self._math._averagepol(self, mask, weight.upper()))
[946]	983	s._add_history("average_pol",varlist)
	984	print_log()
[992]	985	return s
[513]	986
[992]	987	def convert_pol(self, poltype=None):
	988	"""
	989	Convert the data to a different polarisation type.
	990	Parameters:
	991	poltype: The new polarisation type. Valid types are:
	992	"linear", "stokes" and "circular"
	993	"""
	994	varlist = vars()
	995	try:
	996	s = scantable(self._math._convertpol(self, poltype))
	997	except RuntimeError,msg:
	998	if rcParams['verbose']:
	999	print msg
	1000	return
	1001	else:
	1002	raise
	1003	s._add_history("convert_pol",varlist)
	1004	print_log()
	1005	return s
	1006
[876]	1007	def smooth(self, kernel="hanning", width=5.0, insitu=None):
[513]	1008	"""
	1009	Smooth the spectrum by the specified kernel (conserving flux).
	1010	Parameters:
	1011	scan: The input scan
	1012	kernel: The type of smoothing kernel. Select from
	1013	'hanning' (default), 'gaussian' and 'boxcar'.
	1014	The first three characters are sufficient.
	1015	width: The width of the kernel in pixels. For hanning this is
	1016	ignored otherwise it defauls to 5 pixels.
	1017	For 'gaussian' it is the Full Width Half
	1018	Maximum. For 'boxcar' it is the full width.
	1019	insitu: if False a new scantable is returned.
	1020	Otherwise, the scaling is done in-situ
	1021	The default is taken from .asaprc (False)
	1022	Example:
	1023	none
	1024	"""
	1025	if insitu is None: insitu = rcParams['insitu']
[876]	1026	self._math._setinsitu(insitu)
[513]	1027	varlist = vars()
[876]	1028	s = scantable(self._math._smooth(self,kernel,width))
	1029	s._add_history("smooth", varlist)
	1030	print_log()
	1031	if insitu: self._assign(s)
	1032	else: return s
[513]	1033
[876]	1034
	1035	def poly_baseline(self, mask=None, order=0, insitu=None):
[513]	1036	"""
	1037	Return a scan which has been baselined (all rows) by a polynomial.
	1038	Parameters:
[794]	1039	scan: a scantable
	1040	mask: an optional mask
	1041	order: the order of the polynomial (default is 0)
	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	allaxes: If True (default) apply to all spectra. Otherwise
	1046	apply only to the selected (beam/pol/if)spectra only
	1047	The default is taken from .asaprc (True if none)
[513]	1048	Example:
	1049	# return a scan baselined by a third order polynomial,
	1050	# not using a mask
	1051	bscan = scan.poly_baseline(order=3)
[579]	1052	"""
[513]	1053	if insitu is None: insitu = rcParams['insitu']
	1054	varlist = vars()
	1055	if mask is None:
	1056	from numarray import ones
[876]	1057	mask = list(ones(self.nchan(-1)))
[513]	1058	from asap.asapfitter import fitter
	1059	f = fitter()
	1060	f.set_scan(self, mask)
	1061	f.set_function(poly=order)
[876]	1062	s = f.auto_fit(insitu)
	1063	s._add_history("poly_baseline", varlist)
[718]	1064	print_log()
[876]	1065	if insitu: self._assign(s)
	1066	else: return s
[513]	1067
[931]	1068	def auto_poly_baseline(self, mask=[], edge=(0,0), order=0,
[880]	1069	threshold=3, insitu=None):
	1070	"""
	1071	Return a scan which has been baselined (all rows) by a polynomial.
	1072	Spectral lines are detected first using linefinder and masked out
	1073	to avoid them affecting the baseline solution.
	1074
	1075	Parameters:
	1076	mask: an optional mask retreived from scantable
	1077	edge: an optional number of channel to drop at
	1078	the edge of spectrum. If only one value is
	1079	specified, the same number will be dropped from
	1080	both sides of the spectrum. Default is to keep
[907]	1081	all channels. Nested tuples represent individual
[976]	1082	edge selection for different IFs (a number of spectral
	1083	channels can be different)
[880]	1084	order: the order of the polynomial (default is 0)
	1085	threshold: the threshold used by line finder. It is better to
	1086	keep it large as only strong lines affect the
	1087	baseline solution.
	1088	insitu: if False a new scantable is returned.
	1089	Otherwise, the scaling is done in-situ
	1090	The default is taken from .asaprc (False)
	1091
	1092	Example:
	1093	scan2=scan.auto_poly_baseline(order=7)
	1094	"""
	1095	if insitu is None: insitu = rcParams['insitu']
	1096	varlist = vars()
	1097	from asap.asapfitter import fitter
	1098	from asap.asaplinefind import linefinder
	1099	from asap import _is_sequence_or_number as _is_valid
	1100
[976]	1101	# check whether edge is set up for each IF individually
	1102	individualEdge = False;
	1103	if len(edge)>1:
	1104	if isinstance(edge[0],list) or isinstance(edge[0],tuple):
	1105	individualEdge = True;
[907]	1106
	1107	if not _is_valid(edge, int) and not individualEdge:
[909]	1108	raise ValueError, "Parameter 'edge' has to be an integer or a \
[907]	1109	pair of integers specified as a tuple. Nested tuples are allowed \
	1110	to make individual selection for different IFs."
[919]	1111
[976]	1112	curedge = (0,0)
	1113	if individualEdge:
	1114	for edge_par in edge:
	1115	if not _is_valid(edge,int):
	1116	raise ValueError, "Each element of the 'edge' tuple has \
[907]	1117	to be a pair of integers or an integer."
	1118	else:
[976]	1119	curedge = edge;
[880]	1120
	1121	# setup fitter
	1122	f = fitter()
	1123	f.set_function(poly=order)
	1124
	1125	# setup line finder
	1126	fl=linefinder()
	1127	fl.set_options(threshold=threshold)
	1128
	1129	if not insitu:
	1130	workscan=self.copy()
	1131	else:
	1132	workscan=self
	1133
[907]	1134	fl.set_scan(workscan)
	1135
[880]	1136	rows=range(workscan.nrow())
	1137	from asap import asaplog
	1138	asaplog.push("Processing:")
	1139	for r in rows:
	1140	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))
	1141	asaplog.push(msg, False)
[907]	1142
[976]	1143	# figure out edge parameter
	1144	if individualEdge:
	1145	if len(edge)>=workscan.getif(r):
	1146	raise RuntimeError, "Number of edge elements appear to be less than the number of IFs"
	1147	curedge = edge[workscan.getif(r)]
[919]	1148
[976]	1149	# setup line finder
[907]	1150	fl.find_lines(r,mask,curedge)
[880]	1151	f.set_scan(workscan, fl.get_mask())
	1152	f.x = workscan._getabcissa(r)
	1153	f.y = workscan._getspectrum(r)
	1154	f.data = None
	1155	f.fit()
	1156	x = f.get_parameters()
	1157	workscan._setspectrum(f.fitter.getresidual(), r)
	1158	workscan._add_history("poly_baseline", varlist)
	1159	if insitu:
	1160	self._assign(workscan)
	1161	else:
	1162	return workscan
	1163
[914]	1164	def rotate_linpolphase(self, angle):
	1165	"""
	1166	Rotate the phase of the complex polarization O=Q+iU correlation.
	1167	This is always done in situ in the raw data. So if you call this
	1168	function more than once then each call rotates the phase further.
	1169	Parameters:
	1170	angle: The angle (degrees) to rotate (add) by.
	1171	Examples:
	1172	scan.rotate_linpolphase(2.3)
	1173	"""
	1174	varlist = vars()
[936]	1175	self._math._rotate_linpolphase(self, angle)
[914]	1176	self._add_history("rotate_linpolphase", varlist)
	1177	print_log()
	1178	return
[710]	1179
[513]	1180
[914]	1181	def rotate_xyphase(self, angle):
	1182	"""
	1183	Rotate the phase of the XY correlation. This is always done in situ
	1184	in the data. So if you call this function more than once
	1185	then each call rotates the phase further.
	1186	Parameters:
	1187	angle: The angle (degrees) to rotate (add) by.
	1188	Examples:
	1189	scan.rotate_xyphase(2.3)
	1190	"""
	1191	varlist = vars()
[936]	1192	self._math._rotate_xyphase(self, angle)
[914]	1193	self._add_history("rotate_xyphase", varlist)
	1194	print_log()
	1195	return
	1196
	1197	def swap_linears(self):
	1198	"""
	1199	Swap the linear polarisations XX and YY
	1200	"""
	1201	varlist = vars()
[936]	1202	self._math._swap_linears(self)
[914]	1203	self._add_history("swap_linears", varlist)
	1204	print_log()
	1205	return
	1206
	1207	def invert_phase(self):
	1208	"""
	1209	Invert the phase of the complex polarisation
	1210	"""
	1211	varlist = vars()
[936]	1212	self._math._invert_phase(self)
[914]	1213	self._add_history("invert_phase", varlist)
	1214	print_log()
	1215	return
	1216
[876]	1217	def add(self, offset, insitu=None):
[513]	1218	"""
	1219	Return a scan where all spectra have the offset added
	1220	Parameters:
	1221	offset: the offset
	1222	insitu: if False a new scantable is returned.
	1223	Otherwise, the scaling is done in-situ
	1224	The default is taken from .asaprc (False)
	1225	"""
	1226	if insitu is None: insitu = rcParams['insitu']
[876]	1227	self._math._setinsitu(insitu)
[513]	1228	varlist = vars()
[876]	1229	s = scantable(self._math._unaryop(self, offset, "ADD", False))
	1230	s._add_history("add",varlist)
	1231	print_log()
	1232	if insitu:
	1233	self._assign(s)
	1234	else:
[513]	1235	return s
	1236
[876]	1237	def scale(self, factor, tsys=True, insitu=None,):
[513]	1238	"""
	1239	Return a scan where all spectra are scaled by the give 'factor'
	1240	Parameters:
	1241	factor: the scaling factor
	1242	insitu: if False a new scantable is returned.
	1243	Otherwise, the scaling is done in-situ
	1244	The default is taken from .asaprc (False)
	1245	tsys: if True (default) then apply the operation to Tsys
	1246	as well as the data
	1247	"""
	1248	if insitu is None: insitu = rcParams['insitu']
[876]	1249	self._math._setinsitu(insitu)
[513]	1250	varlist = vars()
[876]	1251	s = scantable(self._math._unaryop(self, factor, "MUL", tsys))
	1252	s._add_history("scale",varlist)
	1253	print_log()
	1254	if insitu:
	1255	self._assign(s)
	1256	else:
[513]	1257	return s
	1258
[876]	1259	def auto_quotient(self, mode='time', preserve=True):
[670]	1260	"""
	1261	This function allows to build quotients automatically.
	1262	It assumes the observation to have the same numer of
	1263	"ons" and "offs"
	1264	It will support "closest off in time" in the future
	1265	Parameters:
	1266	mode: the on/off detection mode; 'suffix' (default)
	1267	'suffix' identifies 'off' scans by the
	1268	trailing '_R' (Mopra/Parkes) or
	1269	'_e'/'_w' (Tid)
[710]	1270	preserve: you can preserve (default) the continuum or
	1271	remove it. The equations used are
[670]	1272	preserve: Output = Toff * (on/off) - Toff
	1273	remove: Output = Tref * (on/off) - Ton
	1274	"""
[876]	1275	modes = ["time"]
[670]	1276	if not mode in modes:
[876]	1277	msg = "please provide valid mode. Valid modes are %s" % (modes)
	1278	raise ValueError(msg)
	1279	varlist = vars()
	1280	s = scantable(self._math._quotient(self, mode, preserve))
	1281	s._add_history("auto_quotient",varlist)
	1282	print_log()
	1283	return s
[710]	1284
[513]	1285
[876]	1286
	1287
[718]	1288	def freq_switch(self, insitu=None):
	1289	"""
	1290	Apply frequency switching to the data.
	1291	Parameters:
	1292	insitu: if False a new scantable is returned.
	1293	Otherwise, the swictching is done in-situ
	1294	The default is taken from .asaprc (False)
	1295	Example:
	1296	none
	1297	"""
	1298	if insitu is None: insitu = rcParams['insitu']
[876]	1299	self._math._setinsitu(insitu)
[718]	1300	varlist = vars()
[876]	1301	s = scantable(self._math._freqswitch(self))
	1302	s._add_history("freq_switch",varlist)
	1303	print_log()
	1304	if insitu: self._assign(s)
	1305	else: return s
[718]	1306
[780]	1307	def recalc_azel(self):
	1308	"""
	1309	Recalculate the azimuth and elevation for each position.
	1310	Parameters:
	1311	none
	1312	Example:
	1313	"""
	1314	varlist = vars()
[876]	1315	self._recalcazel()
[780]	1316	self._add_history("recalc_azel", varlist)
	1317	print_log()
	1318	return
	1319
[513]	1320	def __add__(self, other):
	1321	varlist = vars()
	1322	s = None
	1323	if isinstance(other, scantable):
[876]	1324	print "scantable + scantable NYI"
	1325	return
[513]	1326	elif isinstance(other, float):
[876]	1327	s = scantable(self._math._unaryop(self, other, "ADD", False))
[513]	1328	else:
[718]	1329	raise TypeError("Other input is not a scantable or float value")
[513]	1330	s._add_history("operator +", varlist)
[718]	1331	print_log()
[513]	1332	return s
	1333
	1334	def __sub__(self, other):
	1335	"""
	1336	implicit on all axes and on Tsys
	1337	"""
	1338	varlist = vars()
	1339	s = None
	1340	if isinstance(other, scantable):
[876]	1341	print "scantable - scantable NYI"
	1342	return
[513]	1343	elif isinstance(other, float):
[876]	1344	s = scantable(self._math._unaryop(self, other, "SUB", False))
[513]	1345	else:
[718]	1346	raise TypeError("Other input is not a scantable or float value")
[513]	1347	s._add_history("operator -", varlist)
[718]	1348	print_log()
[513]	1349	return s
[710]	1350
[513]	1351	def __mul__(self, other):
	1352	"""
	1353	implicit on all axes and on Tsys
	1354	"""
	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, "MUL", 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
[710]	1368
[513]	1369	def __div__(self, other):
	1370	"""
	1371	implicit on all axes and on Tsys
	1372	"""
	1373	varlist = vars()
	1374	s = None
	1375	if isinstance(other, scantable):
[876]	1376	print "scantable / scantable NYI"
	1377	return
[513]	1378	elif isinstance(other, float):
	1379	if other == 0.0:
[718]	1380	raise ZeroDivisionError("Dividing by zero is not recommended")
[876]	1381	s = scantable(self._math._unaryop(self, other, "DIV", False))
[513]	1382	else:
[718]	1383	raise TypeError("Other input is not a scantable or float value")
[513]	1384	s._add_history("operator /", varlist)
[718]	1385	print_log()
[513]	1386	return s
	1387
[530]	1388	def get_fit(self, row=0):
	1389	"""
	1390	Print or return the stored fits for a row in the scantable
	1391	Parameters:
	1392	row: the row which the fit has been applied to.
	1393	"""
	1394	if row > self.nrow():
	1395	return
[976]	1396	from asap.asapfit import asapfit
[530]	1397	fit = asapfit(self._getfit(row))
[718]	1398	if rcParams['verbose']:
[530]	1399	print fit
	1400	return
	1401	else:
	1402	return fit.as_dict()
	1403
[484]	1404	def _add_history(self, funcname, parameters):
	1405	# create date
	1406	sep = "##"
	1407	from datetime import datetime
	1408	dstr = datetime.now().strftime('%Y/%m/%d %H:%M:%S')
	1409	hist = dstr+sep
	1410	hist += funcname+sep#cdate+sep
	1411	if parameters.has_key('self'): del parameters['self']
	1412	for k,v in parameters.iteritems():
	1413	if type(v) is dict:
	1414	for k2,v2 in v.iteritems():
	1415	hist += k2
	1416	hist += "="
	1417	if isinstance(v2,scantable):
	1418	hist += 'scantable'
	1419	elif k2 == 'mask':
[513]	1420	if isinstance(v2,list) or isinstance(v2,tuple):
	1421	hist += str(self._zip_mask(v2))
	1422	else:
	1423	hist += str(v2)
[484]	1424	else:
[513]	1425	hist += str(v2)
[484]	1426	else:
	1427	hist += k
	1428	hist += "="
	1429	if isinstance(v,scantable):
	1430	hist += 'scantable'
	1431	elif k == 'mask':
[513]	1432	if isinstance(v,list) or isinstance(v,tuple):
	1433	hist += str(self._zip_mask(v))
	1434	else:
	1435	hist += str(v)
[484]	1436	else:
	1437	hist += str(v)
	1438	hist += sep
	1439	hist = hist[:-2] # remove trailing '##'
	1440	self._addhistory(hist)
	1441
[710]	1442
[484]	1443	def _zip_mask(self, mask):
	1444	mask = list(mask)
	1445	i = 0
	1446	segments = []
	1447	while mask[i:].count(1):
	1448	i += mask[i:].index(1)
	1449	if mask[i:].count(0):
	1450	j = i + mask[i:].index(0)
	1451	else:
[710]	1452	j = len(mask)
[484]	1453	segments.append([i,j])
[710]	1454	i = j
[484]	1455	return segments
[714]	1456
[626]	1457	def _get_ordinate_label(self):
	1458	fu = "("+self.get_fluxunit()+")"
	1459	import re
	1460	lbl = "Intensity"
	1461	if re.match(".K.",fu):
	1462	lbl = "Brightness Temperature "+ fu
	1463	elif re.match(".Jy.",fu):
	1464	lbl = "Flux density "+ fu
	1465	return lbl
[710]	1466
[876]	1467	def _check_ifs(self):
	1468	nchans = [self.nchan(i) for i in range(self.nif(-1))]
[889]	1469	nchans = filter(lambda t: t > 0, nchans)
[876]	1470	return (sum(nchans)/len(nchans) == nchans[0])
[976]	1471
	1472	def _fill(self, names, unit, average):
	1473	import os
	1474	varlist = vars()
	1475	from asap._asap import stfiller
	1476	first = True
	1477	fullnames = []
	1478	for name in names:
	1479	name = os.path.expandvars(name)
	1480	name = os.path.expanduser(name)
	1481	if not os.path.exists(name):
	1482	msg = "File '%s' does not exists" % (name)
	1483	if rcParams['verbose']:
	1484	asaplog.push(msg)
	1485	print asaplog.pop().strip()
	1486	return
	1487	raise IOError(msg)
	1488	fullnames.append(name)
	1489	if average:
	1490	asaplog.push('Auto averaging integrations')
	1491	for name in fullnames:
	1492	r = stfiller()
	1493	msg = "Importing %s..." % (name)
	1494	asaplog.push(msg,False)
	1495	print_log()
	1496	r._open(name,-1,-1)
	1497	r._read()
	1498	tbl = r._getdata()
	1499	if average:
[981]	1500	tbl = self._math._average((tbl,),(),'NONE','SCAN')
[976]	1501	#tbl = tbl2
	1502	if not first:
	1503	tbl = self._math._merge([self, tbl])
	1504	#tbl = tbl2
	1505	Scantable.__init__(self, tbl)
	1506	r._close()
	1507	del r,tbl
	1508	first = False
	1509	if unit is not None:
	1510	self.set_fluxunit(unit)
	1511	self.set_freqframe(rcParams['scantable.freqframe'])
	1512	#self._add_history("scantable", varlist)
	1513

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

Download in other formats: