source: branches/Release12/python/scantable.py@ 786

Last change on this file since 786 was 786, checked in by mar637, 19 years ago

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