Context Navigation

source: trunk/python/scantable.py @ 742

Visit:

Last change on this file since 742 was 742, checked in by mar637, 18 years ago
removed old fitter._verbose call
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	from asap import asaplog
261	out = "--------------------------------------------------\n"
262	out += " Cursor position\n"
263	out += "--------------------------------------------------\n"
264	out += 'Beam=%d IF=%d Pol=%d ' % (i,j,k)
265	asaplog.push(out)
266	print_log()
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.set_scan(self, mask)
1078	f.set_function(poly=order)
1079	sf = f.auto_fit(insitu)
1080	if insitu:
1081	self._add_history("poly_baseline", varlist)
1082	print_log()
1083	return
1084	else:
1085	sf._add_history("poly_baseline", varlist)
1086	print_log()
1087	return sf
1088
1089	def auto_poly_baseline(self, mask=None, edge=(0,0), order=0,
1090	threshold=3,insitu=None):
1091	"""
1092	Return a scan which has been baselined (all rows) by a polynomial.
1093	Spectral lines are detected first using linefinder and masked out
1094	to avoid them affecting the baseline solution.
1095
1096	Parameters:
1097	mask: an optional mask retreived from scantable
1098	edge: an optional number of channel to drop at
1099	the edge of spectrum. If only one value is
1100	specified, the same number will be dropped from
1101	both sides of the spectrum. Default is to keep
1102	all channels
1103	order: the order of the polynomial (default is 0)
1104	threshold: the threshold used by line finder. It is better to
1105	keep it large as only strong lines affect the
1106	baseline solution.
1107	insitu: if False a new scantable is returned.
1108	Otherwise, the scaling is done in-situ
1109	The default is taken from .asaprc (False)
1110
1111	Example:
1112	scan2=scan.auto_poly_baseline(order=7)
1113	"""
1114	if insitu is None: insitu = rcParams['insitu']
1115	varlist = vars()
1116	from asap.asapfitter import fitter
1117	from asap.asaplinefind import linefinder
1118	from asap import _is_sequence_or_number as _is_valid
1119
1120	if not _is_valid(edge, int):
1121
1122	raise RuntimeError, "Parameter 'edge' has to be an integer or a \
1123	pair of integers specified as a tuple"
1124
1125	# setup fitter
1126	f = fitter()
1127	f.set_function(poly=order)
1128
1129	# setup line finder
1130	fl=linefinder()
1131	fl.set_options(threshold=threshold)
1132
1133	if not insitu:
1134	workscan=self.copy()
1135	else:
1136	workscan=self
1137
1138	sel=workscan.get_cursor()
1139	rows=range(workscan.nrow())
1140	from asap import asaplog
1141	for i in range(workscan.nbeam()):
1142	workscan.setbeam(i)
1143	for j in range(workscan.nif()):
1144	workscan.setif(j)
1145	for k in range(workscan.npol()):
1146	workscan.setpol(k)
1147	asaplog.push("Processing:")
1148	msg = 'Beam[%d], IF[%d], Pol[%d]' % (i,j,k)
1149	asaplog.push(msg)
1150	for iRow in rows:
1151	fl.set_scan(workscan,mask,edge)
1152	fl.find_lines(iRow)
1153	f.set_scan(workscan, fl.get_mask())
1154	f.x=workscan._getabcissa(iRow)
1155	f.y=workscan._getspectrum(iRow)
1156	f.data=None
1157	f.fit()
1158	x=f.get_parameters()
1159	workscan._setspectrum(f.fitter.getresidual(),iRow)
1160	workscan.set_cursor(sel[0],sel[1],sel[2])
1161	if not insitu:
1162	return workscan
1163
1164	def rotate_linpolphase(self, angle, allaxes=None):
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	allaxes: If True apply to all spectra. Otherwise
1172	apply only to the selected (beam/pol/if)spectra only.
1173	The default is taken from .asaprc (True if none)
1174	Examples:
1175	scan.rotate_linpolphase(2.3)
1176	"""
1177	if allaxes is None: allaxes = rcParams['scantable.allaxes']
1178	varlist = vars()
1179	from asap._asap import _rotate_linpolphase as _rotate
1180	_rotate(self, angle, allaxes)
1181	self._add_history("rotate_linpolphase", varlist)
1182	print_log()
1183	return
1184
1185
1186	def rotate_xyphase(self, angle, allaxes=None):
1187	"""
1188	Rotate the phase of the XY correlation. This is always done in situ
1189	in the data. So if you call this function more than once
1190	then each call rotates the phase further.
1191	Parameters:
1192	angle: The angle (degrees) to rotate (add) by.
1193	allaxes: If True apply to all spectra. Otherwise
1194	apply only to the selected (beam/pol/if)spectra only.
1195	The default is taken from .asaprc (True if none)
1196	Examples:
1197	scan.rotate_xyphase(2.3)
1198	"""
1199	if allaxes is None: allaxes = rcParams['scantable.allaxes']
1200	varlist = vars()
1201	from asap._asap import _rotate_xyphase
1202	_rotate_xyphase(self, angle, allaxes)
1203	self._add_history("rotate_xyphase", varlist)
1204	print_log()
1205	return
1206
1207
1208	def add(self, offset, insitu=None, allaxes=None):
1209	"""
1210	Return a scan where all spectra have the offset added
1211	Parameters:
1212	offset: the offset
1213	insitu: if False a new scantable is returned.
1214	Otherwise, the scaling is done in-situ
1215	The default is taken from .asaprc (False)
1216	allaxes: if True apply to all spectra. Otherwise
1217	apply only to the selected (beam/pol/if)spectra only
1218	The default is taken from .asaprc (True if none)
1219	"""
1220	if allaxes is None: allaxes = rcParams['scantable.allaxes']
1221	if insitu is None: insitu = rcParams['insitu']
1222	varlist = vars()
1223	if not insitu:
1224	from asap._asap import add as _add
1225	s = scantable(_add(self, offset, allaxes))
1226	s._add_history("add",varlist)
1227	print_log()
1228	return s
1229	else:
1230	from asap._asap import add_insitu as _add
1231	_add(self, offset, allaxes)
1232	self._add_history("add",varlist)
1233	print_log()
1234	return
1235
1236	def scale(self, factor, insitu=None, allaxes=None, tsys=True):
1237	"""
1238	Return a scan where all spectra are scaled by the give 'factor'
1239	Parameters:
1240	factor: the scaling factor
1241	insitu: if False a new scantable is returned.
1242	Otherwise, the scaling is done in-situ
1243	The default is taken from .asaprc (False)
1244	allaxes: if True apply to all spectra. Otherwise
1245	apply only to the selected (beam/pol/if)spectra only.
1246	The default is taken from .asaprc (True if none)
1247	tsys: if True (default) then apply the operation to Tsys
1248	as well as the data
1249	"""
1250	if allaxes is None: allaxes = rcParams['scantable.allaxes']
1251	if insitu is None: insitu = rcParams['insitu']
1252	varlist = vars()
1253	if not insitu:
1254	from asap._asap import scale as _scale
1255	s = scantable(_scale(self, factor, allaxes, tsys))
1256	s._add_history("scale",varlist)
1257	print_log()
1258	return s
1259	else:
1260	from asap._asap import scale_insitu as _scale
1261	_scale(self, factor, allaxes, tsys)
1262	self._add_history("scale",varlist)
1263	print_log()
1264	return
1265
1266	def auto_quotient(self, mode='suffix', preserve=True):
1267	"""
1268	This function allows to build quotients automatically.
1269	It assumes the observation to have the same numer of
1270	"ons" and "offs"
1271	It will support "closest off in time" in the future
1272	Parameters:
1273	mode: the on/off detection mode; 'suffix' (default)
1274	'suffix' identifies 'off' scans by the
1275	trailing '_R' (Mopra/Parkes) or
1276	'_e'/'_w' (Tid)
1277	preserve: you can preserve (default) the continuum or
1278	remove it. The equations used are
1279	preserve: Output = Toff * (on/off) - Toff
1280	remove: Output = Tref * (on/off) - Ton
1281	"""
1282	modes = ["suffix","time"]
1283	if not mode in modes:
1284	print "please provide valid mode. Valid modes are %s" % (modes)
1285	return None
1286	from asap._asap import quotient as _quot
1287	if mode == "suffix":
1288	srcs = self.get_scan("*[^_ewR]")
1289	refs = self.get_scan("*[_ewR]")
1290	if isinstance(srcs,scantable) and isinstance(refs,scantable):
1291	ns,nr = srcs.nrow(),refs.nrow()
1292	if nr > ns:
1293	refs = refs.get_scan(range(ns))
1294	print_log()
1295	return scantable(_quot(srcs,refs, preserve))
1296	else:
1297	msg = "Couldn't find any on/off pairs"
1298	if rcParams['verbose']:
1299	print msg
1300	return
1301	else:
1302	raise RuntimeError()
1303	else:
1304	if rcParams['verbose']: print "not yet implemented"
1305	return None
1306
1307	def quotient(self, other, isreference=True, preserve=True):
1308	"""
1309	Return the quotient of a 'source' (on) scan and a 'reference' (off)
1310	scan.
1311	The reference can have just one row, even if the signal has many.
1312	Otherwise they must have the same number of rows.
1313	The cursor of the output scan is set to 0
1314	Parameters:
1315	other: the 'other' scan
1316	isreference: if the 'other' scan is the reference (default)
1317	or source
1318	preserve: you can preserve (default) the continuum or
1319	remove it. The equations used are
1320	preserve: Output = Toff * (on/off) - Toff
1321	remove: Output = Tref * (on/off) - Ton
1322	Example:
1323	# src is a scantable for an 'on' scan, ref for an 'off' scantable
1324	q1 = src.quotient(ref)
1325	q2 = ref.quotient(src, isreference=False)
1326	# gives the same result
1327	"""
1328	from asap._asap import quotient as _quot
1329	try:
1330	s = None
1331	if isreference:
1332	s = scantable(_quot(self, other, preserve))
1333	else:
1334	s = scantable(_quot(other, self, preserve))
1335	print_log()
1336	return s
1337	except RuntimeError,e:
1338	if rcParams['verbose']:
1339	print e
1340	return
1341	else: raise
1342
1343	def freq_switch(self, insitu=None):
1344	"""
1345	Apply frequency switching to the data.
1346	Parameters:
1347	insitu: if False a new scantable is returned.
1348	Otherwise, the swictching is done in-situ
1349	The default is taken from .asaprc (False)
1350	Example:
1351	none
1352	"""
1353	if insitu is None: insitu = rcParams['insitu']
1354	varlist = vars()
1355	try:
1356	if insitu:
1357	from asap._asap import _frequency_switch_insitu
1358	_frequency_switch_insitu(self)
1359	self._add_history("freq_switch", varlist)
1360	print_log()
1361	return
1362	else:
1363	from asap._asap import _frequency_switch
1364	sf = scantable(_frequency_switch(self))
1365	sf._add_history("freq_switch", varlist)
1366	print_log()
1367	return sf
1368	except RuntimeError,e:
1369	if rcParams['verbose']: print e
1370	else: raise
1371
1372	def __add__(self, other):
1373	varlist = vars()
1374	s = None
1375	if isinstance(other, scantable):
1376	from asap._asap import b_operate as _bop
1377	s = scantable(_bop(self, other, 'add', True))
1378	elif isinstance(other, float):
1379	from asap._asap import add as _add
1380	s = scantable(_add(self, other, True))
1381	else:
1382	raise TypeError("Other input is not a scantable or float value")
1383	s._add_history("operator +", varlist)
1384	print_log()
1385	return s
1386
1387
1388	def __sub__(self, other):
1389	"""
1390	implicit on all axes and on Tsys
1391	"""
1392	varlist = vars()
1393	s = None
1394	if isinstance(other, scantable):
1395	from asap._asap import b_operate as _bop
1396	s = scantable(_bop(self, other, 'sub', True))
1397	elif isinstance(other, float):
1398	from asap._asap import add as _add
1399	s = scantable(_add(self, -other, True))
1400	else:
1401	raise TypeError("Other input is not a scantable or float value")
1402	s._add_history("operator -", varlist)
1403	print_log()
1404	return s
1405
1406	def __mul__(self, other):
1407	"""
1408	implicit on all axes and on Tsys
1409	"""
1410	varlist = vars()
1411	s = None
1412	if isinstance(other, scantable):
1413	from asap._asap import b_operate as _bop
1414	s = scantable(_bop(self, other, 'mul', True))
1415	elif isinstance(other, float):
1416	if other == 0.0:
1417	raise ZeroDivisionError("Dividing by zero is not recommended")
1418	from asap._asap import scale as _sca
1419	s = scantable(_sca(self, other, True))
1420	else:
1421	raise TypeError("Other input is not a scantable or float value")
1422	s._add_history("operator *", varlist)
1423	print_log()
1424	return s
1425
1426
1427	def __div__(self, other):
1428	"""
1429	implicit on all axes and on Tsys
1430	"""
1431	varlist = vars()
1432	s = None
1433	if isinstance(other, scantable):
1434	from asap._asap import b_operate as _bop
1435	s = scantable(_bop(self, other, 'div', True))
1436	elif isinstance(other, float):
1437	if other == 0.0:
1438	raise ZeroDivisionError("Dividing by zero is not recommended")
1439	from asap._asap import scale as _sca
1440	s = scantable(_sca(self, 1.0/other, True))
1441	else:
1442	raise TypeError("Other input is not a scantable or float value")
1443	s._add_history("operator /", varlist)
1444	print_log()
1445	return s
1446
1447	def get_fit(self, row=0):
1448	"""
1449	Print or return the stored fits for a row in the scantable
1450	Parameters:
1451	row: the row which the fit has been applied to.
1452	"""
1453	if row > self.nrow():
1454	return
1455	from asap import asapfit
1456	fit = asapfit(self._getfit(row))
1457	if rcParams['verbose']:
1458	print fit
1459	return
1460	else:
1461	return fit.as_dict()
1462
1463	def _add_history(self, funcname, parameters):
1464	# create date
1465	sep = "##"
1466	from datetime import datetime
1467	dstr = datetime.now().strftime('%Y/%m/%d %H:%M:%S')
1468	hist = dstr+sep
1469	hist += funcname+sep#cdate+sep
1470	if parameters.has_key('self'): del parameters['self']
1471	for k,v in parameters.iteritems():
1472	if type(v) is dict:
1473	for k2,v2 in v.iteritems():
1474	hist += k2
1475	hist += "="
1476	if isinstance(v2,scantable):
1477	hist += 'scantable'
1478	elif k2 == 'mask':
1479	if isinstance(v2,list) or isinstance(v2,tuple):
1480	hist += str(self._zip_mask(v2))
1481	else:
1482	hist += str(v2)
1483	else:
1484	hist += str(v2)
1485	else:
1486	hist += k
1487	hist += "="
1488	if isinstance(v,scantable):
1489	hist += 'scantable'
1490	elif k == 'mask':
1491	if isinstance(v,list) or isinstance(v,tuple):
1492	hist += str(self._zip_mask(v))
1493	else:
1494	hist += str(v)
1495	else:
1496	hist += str(v)
1497	hist += sep
1498	hist = hist[:-2] # remove trailing '##'
1499	self._addhistory(hist)
1500
1501
1502	def _zip_mask(self, mask):
1503	mask = list(mask)
1504	i = 0
1505	segments = []
1506	while mask[i:].count(1):
1507	i += mask[i:].index(1)
1508	if mask[i:].count(0):
1509	j = i + mask[i:].index(0)
1510	else:
1511	j = len(mask)
1512	segments.append([i,j])
1513	i = j
1514	return segments
1515
1516	def _get_ordinate_label(self):
1517	fu = "("+self.get_fluxunit()+")"
1518	import re
1519	lbl = "Intensity"
1520	if re.match(".K.",fu):
1521	lbl = "Brightness Temperature "+ fu
1522	elif re.match(".Jy.",fu):
1523	lbl = "Flux density "+ fu
1524	return lbl
1525

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

Download in other formats: