source: trunk/python/scantable.py @ 1005

Last change on this file since 1005 was 1005, checked in by mar637, 18 years ago

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