Context Navigation

source: trunk/python/scantable.py @ 718

Visit:

Last change on this file since 718 was 718, checked in by mar637, 19 years ago
more asaplog migration
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 58.5 KB

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

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

Download in other formats: