Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/python/scantable.py

    r3010 r2687  
    22
    33import os
    4 import re
    54import tempfile
    65import numpy
     
    4645        l=f.readline()
    4746        f.close()
    48         match_pattern = '^Type = (Scantable)? *$'
    49         if re.match(match_pattern,l):
     47        if ( l.find('Scantable') != -1 ):
     48            return True
     49        elif ( l.find('Measurement Set') == -1 and
     50               l.find('Image') == -1 ):
    5051            return True
    5152        else:
     
    174175    return str(showprogress).lower() + ',' + str(minnrow)
    175176
    176 def pack_blinfo(blinfo, maxirow):
    177     """\
    178     convert a dictionary or a list of dictionaries of baseline info
    179     into a list of comma-separated strings.
    180     """
    181     if isinstance(blinfo, dict):
    182         res = do_pack_blinfo(blinfo, maxirow)
    183         return [res] if res != '' else []
    184     elif isinstance(blinfo, list) or isinstance(blinfo, tuple):
    185         res = []
    186         for i in xrange(len(blinfo)):
    187             resi = do_pack_blinfo(blinfo[i], maxirow)
    188             if resi != '':
    189                 res.append(resi)
    190     return res
    191 
    192 def do_pack_blinfo(blinfo, maxirow):
    193     """\
    194     convert a dictionary of baseline info for a spectrum into
    195     a comma-separated string.
    196     """
    197     dinfo = {}
    198     for key in ['row', 'blfunc', 'masklist']:
    199         if blinfo.has_key(key):
    200             val = blinfo[key]
    201             if key == 'row':
    202                 irow = val
    203             if isinstance(val, list) or isinstance(val, tuple):
    204                 slval = []
    205                 for i in xrange(len(val)):
    206                     if isinstance(val[i], list) or isinstance(val[i], tuple):
    207                         for j in xrange(len(val[i])):
    208                             slval.append(str(val[i][j]))
    209                     else:
    210                         slval.append(str(val[i]))
    211                 sval = ",".join(slval)
    212             else:
    213                 sval = str(val)
    214 
    215             dinfo[key] = sval
    216         else:
    217             raise ValueError("'"+key+"' is missing in blinfo.")
    218 
    219     if irow >= maxirow: return ''
    220    
    221     for key in ['order', 'npiece', 'nwave']:
    222         if blinfo.has_key(key):
    223             val = blinfo[key]
    224             if isinstance(val, list) or isinstance(val, tuple):
    225                 slval = []
    226                 for i in xrange(len(val)):
    227                     slval.append(str(val[i]))
    228                 sval = ",".join(slval)
    229             else:
    230                 sval = str(val)
    231             dinfo[key] = sval
    232 
    233     fspec_keys = {'poly': 'order', 'chebyshev': 'order', 'cspline': 'npiece', 'sinusoid': 'nwave'}
    234 
    235     fspec_key = fspec_keys[dinfo['blfunc']]
    236     if not blinfo.has_key(fspec_key):
    237         raise ValueError("'"+fspec_key+"' is missing in blinfo.")
    238 
    239     clip_params_n = 0
    240     for key in ['clipthresh', 'clipniter']:
    241         if blinfo.has_key(key):
    242             clip_params_n += 1
    243             dinfo[key] = str(blinfo[key])
    244 
    245     if clip_params_n == 0:
    246         dinfo['clipthresh'] = '0.0'
    247         dinfo['clipniter']  = '0'
    248     elif clip_params_n != 2:
    249         raise ValueError("both 'clipthresh' and 'clipniter' must be given for n-sigma clipping.")
    250 
    251     lf_params_n = 0
    252     for key in ['thresh', 'edge', 'chan_avg_limit']:
    253         if blinfo.has_key(key):
    254             lf_params_n += 1
    255             val = blinfo[key]
    256             if isinstance(val, list) or isinstance(val, tuple):
    257                 slval = []
    258                 for i in xrange(len(val)):
    259                     slval.append(str(val[i]))
    260                 sval = ",".join(slval)
    261             else:
    262                 sval = str(val)
    263             dinfo[key] = sval
    264 
    265     if lf_params_n == 3:
    266         dinfo['use_linefinder'] = 'true'
    267     elif lf_params_n == 0:
    268         dinfo['use_linefinder'] = 'false'
    269         dinfo['thresh']         = ''
    270         dinfo['edge']           = ''
    271         dinfo['chan_avg_limit'] = ''
    272     else:
    273         raise ValueError("all of 'thresh', 'edge' and 'chan_avg_limit' must be given to use linefinder.")
    274    
    275     slblinfo = [dinfo['row'], dinfo['blfunc'], dinfo[fspec_key], dinfo['masklist'], \
    276                 dinfo['clipthresh'], dinfo['clipniter'], \
    277                 dinfo['use_linefinder'], dinfo['thresh'], dinfo['edge'], dinfo['chan_avg_limit']]
    278    
    279     return ":".join(slblinfo)
    280 
    281 def parse_fitresult(sres):
    282     """\
    283     Parse the returned value of apply_bltable() or sub_baseline() and
    284     extract row number, the best-fit coefficients and rms, then pack
    285     them into a dictionary.
    286     The input value is generated by Scantable::packFittingResults() and
    287     formatted as 'row:coeff[0],coeff[1],..,coeff[n-1]:rms'.
    288     """
    289     res = []
    290     for i in xrange(len(sres)):
    291         (srow, scoeff, srms) = sres[i].split(":")
    292         row = int(srow)
    293         rms = float(srms)
    294         lscoeff = scoeff.split(",")
    295         coeff = []
    296         for j in xrange(len(lscoeff)):
    297             coeff.append(float(lscoeff[j]))
    298         res.append({'row': row, 'coeff': coeff, 'rms': rms})
    299 
    300     return res
    301 
    302 def is_number(s):
    303     s = s.strip()
    304     res = True
    305     try:
    306         a = float(s)
    307         res = True
    308     except:
    309         res = False
    310     finally:
    311         return res
    312 
    313 def is_frequency(s):
    314     s = s.strip()
    315     return (s[-2:].lower() == "hz")
    316 
    317 def get_freq_by_string(s1, s2):
    318     if not (is_number(s1) and is_frequency(s2)):
    319         raise RuntimeError("Invalid input string.")
    320    
    321     prefix_list = ["a", "f", "p", "n", "u", "m", ".", "k", "M", "G", "T", "P", "E"]
    322     factor_list = [1e-18, 1e-15, 1e-12, 1e-9, 1e-6, 1e-3, 1.0, 1e+3, 1e+6, 1e+9, 1e+12, 1e+15, 1e+18]
    323 
    324     s1 = s1.strip()
    325     s2 = s2.strip()
    326    
    327     prefix = s2[-3:-2]
    328     if is_number(prefix):
    329         res1 = float(s1)
    330         res2 = float(s2[:-2])
    331     else:
    332         factor = factor_list[prefix_list.index(prefix)]
    333         res1 = float(s1) * factor
    334         res2 = float(s2[:-3]) * factor
    335 
    336     return (res1, res2)
    337 
    338 def is_velocity(s):
    339     s = s.strip()
    340     return (s[-3:].lower() == "m/s")
    341 
    342 def get_velocity_by_string(s1, s2):
    343     if not (is_number(s1) and is_velocity(s2)):
    344         raise RuntimeError("Invalid input string.")
    345 
    346     # note that the default velocity unit is km/s
    347     prefix_list = [".", "k"]
    348     factor_list = [1e-3, 1.0]
    349 
    350     s1 = s1.strip()
    351     s2 = s2.strip()
    352 
    353     prefix = s2[-4:-3]
    354     if is_number(prefix): # in case velocity unit m/s
    355         res1 = float(s1) * 1e-3
    356         res2 = float(s2[:-3]) * 1e-3
    357     else:
    358         factor = factor_list[prefix_list.index(prefix)]
    359         res1 = float(s1) * factor
    360         res2 = float(s2[:-4]) * factor
    361 
    362     return (res1, res2)
    363 
    364 def get_frequency_by_velocity(restfreq, vel, doppler):
    365     # vel is in unit of km/s
    366 
    367     # speed of light
    368     vel_c = 299792.458
    369 
    370     import math
    371     r = vel / vel_c
    372 
    373     if doppler.lower() == 'radio':
    374         return restfreq * (1.0 - r)
    375     if doppler.lower() == 'optical':
    376         return restfreq / (1.0 + r)
    377     else:
    378         return restfreq * math.sqrt((1.0 - r) / (1.0 + r))
    379 
    380 def get_restfreq_in_Hz(s_restfreq):
    381     value = 0.0
    382     unit = ""
    383     s = s_restfreq.replace(" ","")
    384 
    385     for i in range(len(s))[::-1]:
    386         if s[i].isalpha():
    387             unit = s[i] + unit
    388         else:
    389             value = float(s[0:i+1])
    390             break
    391 
    392     if (unit == "") or (unit.lower() == "hz"):
    393         return value
    394     elif (len(unit) == 3) and (unit[1:3].lower() == "hz"):
    395         unitprefix = unit[0]
    396         factor = 1.0
    397 
    398         prefix_list = ["a", "f", "p", "n", "u", "m", ".", "k", "M", "G", "T", "P", "E"]
    399         factor_list = [1e-18, 1e-15, 1e-12, 1e-9, 1e-6, 1e-3, 1.0, 1e+3, 1e+6, 1e+9, 1e+12, 1e+15, 1e+18]
    400         factor = factor_list[prefix_list.index(unitprefix)]
    401         """
    402         if (unitprefix == 'a'):
    403             factor = 1.0e-18
    404         elif (unitprefix == 'f'):
    405             factor = 1.0e-15
    406         elif (unitprefix == 'p'):
    407             factor = 1.0e-12
    408         elif (unitprefix == 'n'):
    409             factor = 1.0e-9
    410         elif (unitprefix == 'u'):
    411             factor = 1.0e-6
    412         elif (unitprefix == 'm'):
    413             factor = 1.0e-3
    414         elif (unitprefix == 'k'):
    415             factor = 1.0e+3
    416         elif (unitprefix == 'M'):
    417             factor = 1.0e+6
    418         elif (unitprefix == 'G'):
    419             factor = 1.0e+9
    420         elif (unitprefix == 'T'):
    421             factor = 1.0e+12
    422         elif (unitprefix == 'P'):
    423             factor = 1.0e+15
    424         elif (unitprefix == 'E'):
    425             factor = 1.0e+18
    426         """
    427         return value*factor
    428     else:
    429         mesg = "wrong unit of restfreq."
    430         raise Exception, mesg
    431 
    432 def normalise_restfreq(in_restfreq):
    433     if isinstance(in_restfreq, float):
    434         return in_restfreq
    435     elif isinstance(in_restfreq, int) or isinstance(in_restfreq, long):
    436         return float(in_restfreq)
    437     elif isinstance(in_restfreq, str):
    438         return get_restfreq_in_Hz(in_restfreq)
    439     elif isinstance(in_restfreq, list) or isinstance(in_restfreq, numpy.ndarray):
    440         if isinstance(in_restfreq, numpy.ndarray):
    441             if len(in_restfreq.shape) > 1:
    442                 mesg = "given in numpy.ndarray, in_restfreq must be 1-D."
    443                 raise Exception, mesg
    444        
    445         res = []
    446         for i in xrange(len(in_restfreq)):
    447             elem = in_restfreq[i]
    448             if isinstance(elem, float):
    449                 res.append(elem)
    450             elif isinstance(elem, int) or isinstance(elem, long):
    451                 res.append(float(elem))
    452             elif isinstance(elem, str):
    453                 res.append(get_restfreq_in_Hz(elem))
    454             elif isinstance(elem, dict):
    455                 if isinstance(elem["value"], float):
    456                     res.append(elem)
    457                 elif isinstance(elem["value"], int):
    458                     dictelem = {}
    459                     dictelem["name"]  = elem["name"]
    460                     dictelem["value"] = float(elem["value"])
    461                     res.append(dictelem)
    462                 elif isinstance(elem["value"], str):
    463                     dictelem = {}
    464                     dictelem["name"]  = elem["name"]
    465                     dictelem["value"] = get_restfreq_in_Hz(elem["value"])
    466                     res.append(dictelem)
    467             else:
    468                 mesg = "restfreq elements must be float, int, or string."
    469                 raise Exception, mesg
    470         return res
    471     else:
    472         mesg = "wrong type of restfreq given."
    473         raise Exception, mesg
    474 
    475 def set_restfreq(s, restfreq):
    476     rfset = (restfreq != '') and (restfreq != [])
    477     if rfset:
    478         s.set_restfreqs(normalise_restfreq(restfreq))
    479 
    480177class scantable(Scantable):
    481178    """\
     
    513210                          Default (false) is taken from rc file.
    514211
    515             getpt:        Whether to import direction from MS/POINTING
    516                           table properly or not.
    517                           This is effective only when filename is MS.
    518                           The default (True) is to import direction
    519                           from MS/POINTING.
    520212        """
    521213        if average is None:
     
    552244                    self._fill([filename], unit, average, opts)
    553245                elif os.path.isfile(filename):
    554                     opts={'nro': {}}
    555                     nrokeys=['freqref']
    556                     for key in nrokeys:
    557                         if key in args.keys():
    558                             opts['nro'][key] = args[key]
    559                     self._fill([filename], unit, average, opts)
     246                    self._fill([filename], unit, average)
    560247                    # only apply to new data not "copy constructor"
    561248                    self.parallactify(parallactify)
     
    891578
    892579    @asaplog_post_dec
    893     def stats(self, stat='stddev', mask=None, form='3.3f', row=None, skip_flaggedrow=False):
     580    def stats(self, stat='stddev', mask=None, form='3.3f', row=None):
    894581        """\
    895582        Determine the specified statistic of the current beam/if/pol
     
    909596            row:     row number of spectrum to process.
    910597                     (default is None: for all rows)
    911 
    912             skip_flaggedrow: if True, skip outputting text for flagged
    913                              spectra. default is False.
    914598
    915599        Example:
     
    924608                             "number of channels. Please use setselection() "
    925609                             "to select individual IFs")
     610        rtnabc = False
     611        if stat.lower().endswith('_abc'): rtnabc = True
    926612        getchan = False
    927613        if stat.lower().startswith('min') or stat.lower().startswith('max'):
     
    929615            getchan = True
    930616            statvals = []
    931 
    932         rtnabc = False
    933         if stat.lower().endswith('_abc'):
    934             rtnabc = True
    935         else:
     617        if not rtnabc:
    936618            if row == None:
    937619                statvals = self._math._stats(self, mask, stat)
     
    959641            statunit= ''
    960642            if getchan:
    961                 if self._is_all_chan_flagged(i):
    962                     if rtnabc:
    963                         statvals.append(None)
     643                qx, qy = self.chan2data(rowno=i, chan=chan[i])
     644                if rtnabc:
     645                    statvals.append(qx['value'])
     646                    refstr = ('(value: %'+form) % (qy['value'])+' ['+qy['unit']+'])'
     647                    statunit= '['+qx['unit']+']'
    964648                else:
    965                     qx, qy = self.chan2data(rowno=i, chan=chan[i])
    966                     if rtnabc:
    967                         statvals.append(qx['value'])
    968                         refstr = ('(value: %'+form) % (qy['value'])+' ['+qy['unit']+'])'
    969                         statunit= '['+qx['unit']+']'
    970                     else:
    971                         refstr = ('(@ %'+form) % (qx['value'])+' ['+qx['unit']+'])'
    972 
    973             if self._is_all_chan_flagged(i):
    974                 if not rtnabc:
    975                     statvals[i] = None
    976                 if skip_flaggedrow:
    977                     continue
     649                    refstr = ('(@ %'+form) % (qx['value'])+' ['+qx['unit']+'])'
    978650
    979651            tm = self._gettime(i)
     
    987659            if len(rows) > 1:
    988660                # out += ('= %'+form) % (outvec[i]) +'   '+refstr+'\n'
    989                 if statvals[i] is None:
    990                     out += ('= None(flagged)') + '   '+refstr+'\n'
    991                 else:
    992                     out += ('= %'+form) % (statvals[i]) +'   '+refstr+'\n'
     661                out += ('= %'+form) % (statvals[i]) +'   '+refstr+'\n'
    993662            else:
    994663                # out += ('= %'+form) % (outvec[0]) +'   '+refstr+'\n'
    995                 if statvals[0] is None:
    996                     out += ('= None(flagged)') + '   '+refstr+'\n'
    997                 else:
    998                     out += ('= %'+form) % (statvals[0]) +'   '+refstr+'\n'
     664                out += ('= %'+form) % (statvals[0]) +'   '+refstr+'\n'
    999665            out +=  sep+"\n"
    1000666
     
    1017683        asaplog.push(''.join(x), False)
    1018684
    1019         if skip_flaggedrow:
    1020             nstatvals = len(statvals)
    1021             for i in reversed(xrange(nstatvals)):
    1022                 if statvals[i] is None:
    1023                     del statvals[i]
    1024685        return statvals
    1025686
     
    1104765        return self._get_column( self._gettsysspectrum, row )
    1105766
    1106     def set_tsys(self, values, row=-1):
    1107         """\
    1108         Set the Tsys value(s) of the given 'row' or the whole scantable
    1109         (selection).
    1110        
    1111         Parameters:
    1112 
    1113             values:    a scalar or list (if Tsys is a vector) of Tsys value(s)
    1114             row:       the row number to apply Tsys values to.
    1115                        (default all rows)
    1116                        
    1117         """
    1118            
    1119         if not hasattr(values, "__len__"):
    1120             values = [values]
    1121         self._settsys(values, row)
    1122 
    1123767    def get_weather(self, row=-1):
    1124768        """\
    1125         Return the weather information.
     769        Return the weather informations.
    1126770
    1127771        Parameters:
     
    1134778
    1135779        """
    1136         if row >= len(self):
    1137             raise IndexError("row out of range")
     780
    1138781        values = self._get_column(self._get_weather, row)
    1139782        if row > -1:
     
    1145788            out = []
    1146789            for r in values:
     790
    1147791                out.append({'temperature': r[0],
    1148792                            'pressure': r[1], 'humidity' : r[2],
     
    13611005        self._add_history("set_feedtype", vars())
    13621006
    1363     @asaplog_post_dec
    1364     def get_doppler(self):
    1365         """\
    1366         Get the doppler.
    1367         """
    1368         return self._getcoordinfo()[2]
    1369    
    13701007    @asaplog_post_dec
    13711008    def set_doppler(self, doppler='RADIO'):
     
    18341471
    18351472    @asaplog_post_dec
    1836     def parse_spw_selection(self, selectstring, restfreq=None, frame=None, doppler=None):
    1837         """
    1838         Parse MS type spw/channel selection syntax.
    1839 
    1840         Parameters:
    1841             selectstring : A string expression of spw and channel selection.
    1842                            Comma-separated expressions mean different spw -
    1843                            channel combinations. Spws and channel selections
    1844                            are partitioned by a colon ':'. In a single
    1845                            selection expression, you can put multiple values
    1846                            separated by semicolons ';'. Both for spw and
    1847                            channel selection, allowed cases include single
    1848                            value, blank('') or asterisk('*') to specify all
    1849                            available values, two values connected with a
    1850                            tilde ('~') to specify an inclusive range. Unit
    1851                            strings for frequency or velocity can be added to
    1852                            the tilde-connected values. For channel selection
    1853                            expression, placing a '<' or a '>' is possible to
    1854                            specify a semi-infinite interval as well.
    1855 
    1856                      examples:
    1857                            '' or '*'   = all spws (all channels)
    1858                            '<2,4~6,9'  = Spws 0,1,4,5,6,9 (all channels)
    1859                            '3:3~45;60' = channels 3 to 45 and 60 in spw 3
    1860                            '0~1:2~6,8' = channels 2 to 6 in spws 0,1, and
    1861                                          all channels in spw8
    1862                            '1.3~1.5GHz' = all spws whose central frequency
    1863                                           falls in frequency range between
    1864                                           1.3GHz and 1.5GHz.
    1865                            '1.3~1.5GHz:1.3~1.5GHz' = channels which fall
    1866                                                      between the specified
    1867                                                      frequency range in spws
    1868                                                      whose central frequency
    1869                                                      falls in the specified
    1870                                                      frequency range.
    1871                            '1:-200~250km/s' = channels that fall between the
    1872                                               specified velocity range in
    1873                                               spw 1.
    1874             restfreq: the rest frequency.
    1875                      examples: '115.2712GHz', 115271201800.0
    1876             frame:   an optional frame type, default 'LSRK'. Valid frames are:
    1877                      'TOPO', 'LSRD', 'LSRK', 'BARY',
    1878                      'GEO', 'GALACTO', 'LGROUP', 'CMB'
    1879             doppler: one of 'RADIO', 'OPTICAL', 'Z', 'BETA', 'GAMMA'
    1880         Returns:
    1881         A dictionary of selected (valid) spw and masklist pairs,
    1882         e.g. {'0': [[50,250],[350,462]], '2': [[100,400],[550,974]]}
    1883         """
    1884         if not isinstance(selectstring, str):
    1885             asaplog.post()
    1886             asaplog.push("Expression of spw/channel selection must be a string.")
    1887             asaplog.post("ERROR")
    1888 
    1889         orig_unit = self.get_unit()
    1890         self.set_unit('channel')
    1891        
    1892         if restfreq is not None:
    1893             orig_molids = self._getmolidcol_list()
    1894             set_restfreq(self, restfreq)
    1895 
    1896         orig_coord = self._getcoordinfo()
    1897 
    1898         if frame is not None:
    1899             orig_frame = orig_coord[1]
    1900             self.set_freqframe(frame)
    1901 
    1902         if doppler is not None:
    1903             orig_doppler = orig_coord[2]
    1904             self.set_doppler(doppler)
    1905        
    1906         valid_ifs = self.getifnos()
    1907 
    1908         comma_sep = selectstring.split(",")
    1909         res = {}
    1910 
    1911         for cms_elem in comma_sep:
    1912             colon_sep = cms_elem.split(":")
    1913            
    1914             if (len(colon_sep) > 2):
    1915                 raise RuntimeError("Invalid selection expression: more than two colons!")
    1916            
    1917             # parse spw expression and store result in spw_list.
    1918             # allowed cases include '', '*', 'a', '<a', '>a', 'a~b',
    1919             # 'a~b*Hz' (where * can be '', 'k', 'M', 'G' etc.),
    1920             # 'a~b*m/s' (where * can be '' or 'k') and also
    1921             # several of the above expressions connected with ';'.
    1922            
    1923             spw_list = []
    1924 
    1925             semicolon_sep = colon_sep[0].split(";")
    1926            
    1927             for scs_elem in semicolon_sep:
    1928                 scs_elem = scs_elem.strip()
    1929                
    1930                 lt_sep = scs_elem.split("<")
    1931                 gt_sep = scs_elem.split(">")
    1932                 ti_sep = scs_elem.split("~")
    1933                
    1934                 lt_sep_length = len(lt_sep)
    1935                 gt_sep_length = len(gt_sep)
    1936                 ti_sep_length = len(ti_sep)
    1937                
    1938                 len_product = lt_sep_length * gt_sep_length * ti_sep_length
    1939 
    1940                 if (len_product > 2):
    1941                     # '<', '>' and '~' must not coexist in a single spw expression
    1942                    
    1943                     raise RuntimeError("Invalid spw selection.")
    1944                
    1945                 elif (len_product == 1):
    1946                     # '', '*', or single spw number.
    1947                    
    1948                     if (scs_elem == "") or (scs_elem == "*"):
    1949                         spw_list = valid_ifs[:] # deep copy
    1950                    
    1951                     else: # single number
    1952                         expr = int(scs_elem)
    1953                         spw_list.append(expr)
    1954                         if expr not in valid_ifs:
    1955                             asaplog.push("Invalid spw given. Ignored.")
    1956                    
    1957                 else: # (len_product == 2)
    1958                     # namely, one of '<', '>' or '~' appears just once.
    1959                    
    1960                     if (lt_sep_length == 2): # '<a'
    1961                         if is_number(lt_sep[1]):
    1962                             no_valid_spw = True
    1963                             for i in valid_ifs:
    1964                                 if (i < float(lt_sep[1])):
    1965                                     spw_list.append(i)
    1966                                     no_valid_spw = False
    1967 
    1968                             if no_valid_spw:
    1969                                 raise ValueError("Invalid spw selection ('<" + str(lt_sep[1]) + "').")
    1970                        
    1971                         else:
    1972                             raise RuntimeError("Invalid spw selection.")
    1973                        
    1974                     elif (gt_sep_length == 2): # '>a'
    1975                         if is_number(gt_sep[1]):
    1976                             no_valid_spw = True
    1977                             for i in valid_ifs:
    1978                                 if (i > float(gt_sep[1])):
    1979                                     spw_list.append(i)
    1980                                     no_valid_spw = False
    1981                            
    1982                             if no_valid_spw:
    1983                                 raise ValueError("Invalid spw selection ('>" + str(gt_sep[1]) + "').")
    1984                        
    1985                         else:
    1986                             raise RuntimeError("Invalid spw selection.")
    1987                        
    1988                     else: # (ti_sep_length == 2) where both boundaries inclusive
    1989                         expr0 = ti_sep[0].strip()
    1990                         expr1 = ti_sep[1].strip()
    1991 
    1992                         if is_number(expr0) and is_number(expr1):
    1993                             # 'a~b'
    1994                             expr_pmin = min(float(expr0), float(expr1))
    1995                             expr_pmax = max(float(expr0), float(expr1))
    1996                             has_invalid_spw = False
    1997                             no_valid_spw = True
    1998                            
    1999                             for i in valid_ifs:
    2000                                 if (expr_pmin <= i) and (i <= expr_pmax):
    2001                                     spw_list.append(i)
    2002                                     no_valid_spw = False
    2003                                 else:
    2004                                     has_invalid_spw = True
    2005 
    2006                             if has_invalid_spw:
    2007                                 msg = "Invalid spw is given. Ignored."
    2008                                 asaplog.push(msg)
    2009                                 asaplog.post()
    2010 
    2011                             if no_valid_spw:
    2012                                 raise ValueError("No valid spw in range ('" + str(expr_pmin) + "~" + str(expr_pmax) + "').")
    2013                        
    2014                         elif is_number(expr0) and is_frequency(expr1):
    2015                             # 'a~b*Hz'
    2016                             (expr_f0, expr_f1) = get_freq_by_string(expr0, expr1)
    2017                             expr_fmin = min(expr_f0, expr_f1)
    2018                             expr_fmax = max(expr_f0, expr_f1)
    2019                             no_valid_spw = True
    2020                            
    2021                             for coord in self._get_coordinate_list():
    2022                                 spw = coord['if']
    2023                                
    2024                                 """
    2025                                 expr_p0 = coord['coord'].to_pixel(expr_f0)
    2026                                 expr_p1 = coord['coord'].to_pixel(expr_f1)
    2027                                 expr_pmin = min(expr_p0, expr_p1)
    2028                                 expr_pmax = max(expr_p0, expr_p1)
    2029                                
    2030                                 pmin = 0.0
    2031                                 pmax = float(self.nchan(spw) - 1)
    2032 
    2033                                 if ((expr_pmax - pmin)*(expr_pmin - pmax) <= 0.0):
    2034                                     spw_list.append(spw)
    2035                                     no_valid_spw = False
    2036                                 """
    2037 
    2038                                 crd = coord['coord']
    2039                                 fhead = crd.to_frequency(0)
    2040                                 ftail = crd.to_frequency(self.nchan(spw) - 1)
    2041                                 fcen  = (fhead + ftail) / 2.0
    2042 
    2043                                 if ((expr_fmin <= fcen) and (fcen <= expr_fmax)):
    2044                                     spw_list.append(spw)
    2045                                     no_valid_spw = False
    2046                                
    2047                             if no_valid_spw:
    2048                                 raise ValueError("No valid spw in range ('" + str(expr0) + "~" + str(expr1) + "').")
    2049                                
    2050                         elif is_number(expr0) and is_velocity(expr1):
    2051                             # 'a~b*m/s'
    2052                             (expr_v0, expr_v1) = get_velocity_by_string(expr0, expr1)
    2053                             expr_vmin = min(expr_v0, expr_v1)
    2054                             expr_vmax = max(expr_v0, expr_v1)
    2055                             no_valid_spw = True
    2056                            
    2057                             for coord in self._get_coordinate_list():
    2058                                 spw = coord['if']
    2059 
    2060                                 """
    2061                                 pmin = 0.0
    2062                                 pmax = float(self.nchan(spw) - 1)
    2063                                
    2064                                 vel0 = coord['coord'].to_velocity(pmin)
    2065                                 vel1 = coord['coord'].to_velocity(pmax)
    2066                                
    2067                                 vmin = min(vel0, vel1)
    2068                                 vmax = max(vel0, vel1)
    2069 
    2070                                 if ((expr_vmax - vmin)*(expr_vmin - vmax) <= 0.0):
    2071                                     spw_list.append(spw)
    2072                                     no_valid_spw = False
    2073                                 """
    2074 
    2075                                 crd = coord['coord']
    2076                                 fhead = crd.to_frequency(0)
    2077                                 ftail = crd.to_frequency(self.nchan(spw) - 1)
    2078                                 fcen  = (fhead + ftail) / 2.0
    2079                                 vcen  = crd.to_velocity(crd.to_pixel(fcen))
    2080 
    2081                                 if ((expr_vmin <= vcen) and (vcen <= expr_vmax)):
    2082                                     spw_list.append(spw)
    2083                                     no_valid_spw = False
    2084 
    2085                             if no_valid_spw:
    2086                                 raise ValueError("No valid spw in range ('" + str(expr0) + "~" + str(expr1) + "').")
    2087                            
    2088                         else:
    2089                             # cases such as 'aGHz~bkm/s' are not allowed now
    2090                             raise RuntimeError("Invalid spw selection.")
    2091 
    2092             # check spw list and remove invalid ones.
    2093             # if no valid spw left, emit ValueError.
    2094             if len(spw_list) == 0:
    2095                 raise ValueError("No valid spw in given range.")
    2096            
    2097             # parse channel expression and store the result in crange_list.
    2098             # allowed cases include '', 'a~b', 'a*Hz~b*Hz' (where * can be
    2099             # '', 'k', 'M', 'G' etc.), 'a*m/s~b*m/s' (where * can be '' or 'k')
    2100             # and also several of the above expressions connected with ';'.
    2101            
    2102             for spw in spw_list:
    2103                 pmin = 0.0
    2104                 pmax = float(self.nchan(spw) - 1)
    2105 
    2106                 molid = self._getmolidcol_list()[self.get_first_rowno_by_if(spw)]
    2107                
    2108                 if (len(colon_sep) == 1):
    2109                     # no expression for channel selection,
    2110                     # which means all channels are to be selected.
    2111                     crange_list = [[pmin, pmax]]
    2112                
    2113                 else: # (len(colon_sep) == 2)
    2114                     crange_list = []
    2115                    
    2116                     found = False
    2117                     for i in self._get_coordinate_list():
    2118                         if (i['if'] == spw):
    2119                             coord = i['coord']
    2120                             found = True
    2121                             break
    2122 
    2123                     if found:
    2124                         semicolon_sep = colon_sep[1].split(";")
    2125                         for scs_elem in semicolon_sep:
    2126                             scs_elem = scs_elem.strip()
    2127 
    2128                             ti_sep = scs_elem.split("~")
    2129                             ti_sep_length = len(ti_sep)
    2130 
    2131                             if (ti_sep_length > 2):
    2132                                 raise RuntimeError("Invalid channel selection.")
    2133                        
    2134                             elif (ti_sep_length == 1):
    2135                                 if (scs_elem == "") or (scs_elem == "*"):
    2136                                     # '' and '*' for all channels
    2137                                     crange_list = [[pmin, pmax]]
    2138                                     break
    2139                                 elif (is_number(scs_elem)):
    2140                                     # single channel given
    2141                                     crange_list.append([float(scs_elem), float(scs_elem)])
    2142                                 else:
    2143                                     raise RuntimeError("Invalid channel selection.")
    2144 
    2145                             else: #(ti_sep_length == 2)
    2146                                 expr0 = ti_sep[0].strip()
    2147                                 expr1 = ti_sep[1].strip()
    2148 
    2149                                 if is_number(expr0) and is_number(expr1):
    2150                                     # 'a~b'
    2151                                     expr_pmin = min(float(expr0), float(expr1))
    2152                                     expr_pmax = max(float(expr0), float(expr1))
    2153 
    2154                                 elif is_number(expr0) and is_frequency(expr1):
    2155                                     # 'a~b*Hz'
    2156                                     (expr_f0, expr_f1) = get_freq_by_string(expr0, expr1)
    2157                                     expr_p0 = coord.to_pixel(expr_f0)
    2158                                     expr_p1 = coord.to_pixel(expr_f1)
    2159                                     expr_pmin = min(expr_p0, expr_p1)
    2160                                     expr_pmax = max(expr_p0, expr_p1)
    2161 
    2162                                 elif is_number(expr0) and is_velocity(expr1):
    2163                                     # 'a~b*m/s'
    2164                                     restf = self.get_restfreqs()[molid][0]
    2165                                     (expr_v0, expr_v1) = get_velocity_by_string(expr0, expr1)
    2166                                     dppl = self.get_doppler()
    2167                                     expr_f0 = get_frequency_by_velocity(restf, expr_v0, dppl)
    2168                                     expr_f1 = get_frequency_by_velocity(restf, expr_v1, dppl)
    2169                                     expr_p0 = coord.to_pixel(expr_f0)
    2170                                     expr_p1 = coord.to_pixel(expr_f1)
    2171                                     expr_pmin = min(expr_p0, expr_p1)
    2172                                     expr_pmax = max(expr_p0, expr_p1)
    2173                            
    2174                                 else:
    2175                                     # cases such as 'aGHz~bkm/s' are not allowed now
    2176                                     raise RuntimeError("Invalid channel selection.")
    2177 
    2178                                 cmin = max(pmin, expr_pmin)
    2179                                 cmax = min(pmax, expr_pmax)
    2180                                 # if the given range of channel selection has overwrap with
    2181                                 # that of current spw, output the overwrap area.
    2182                                 if (cmin <= cmax):
    2183                                     cmin = float(int(cmin + 0.5))
    2184                                     cmax = float(int(cmax + 0.5))
    2185                                     crange_list.append([cmin, cmax])
    2186 
    2187                     if (len(crange_list) == 0):
    2188                         crange_list.append([])
    2189 
    2190                 if (len(crange_list[0]) > 0):
    2191                     if res.has_key(spw):
    2192                         res[spw].extend(crange_list)
    2193                     else:
    2194                         res[spw] = crange_list
    2195 
    2196         for spw in res.keys():
    2197             if spw in valid_ifs:
    2198                 # remove duplicated channel ranges
    2199                 for i in reversed(xrange(len(res[spw]))):
    2200                     for j in xrange(i):
    2201                         if ((res[spw][i][0]-res[spw][j][1])*(res[spw][i][1]-res[spw][j][0]) <= 0) or \
    2202                             (min(abs(res[spw][i][0]-res[spw][j][1]),abs(res[spw][j][0]-res[spw][i][1])) == 1):
    2203                             asaplog.post()
    2204                             merge_warn_mesg = "Spw " + str(spw) + ": overwrapping channel ranges are merged."
    2205                             asaplog.push(merge_warn_mesg)
    2206                             asaplog.post('WARN')
    2207                             res[spw][j][0] = min(res[spw][i][0], res[spw][j][0])
    2208                             res[spw][j][1] = max(res[spw][i][1], res[spw][j][1])
    2209                             res[spw].pop(i)
    2210                             break
    2211             else:
    2212                 del res[spw]
    2213 
    2214         if len(res) == 0:
    2215             raise RuntimeError("No valid spw.")
    2216        
    2217         # restore original values
    2218         self.set_unit(orig_unit)
    2219         if restfreq is not None:
    2220             self._setmolidcol_list(orig_molids)
    2221         if frame is not None:
    2222             self.set_freqframe(orig_frame)
    2223         if doppler is not None:
    2224             self.set_doppler(orig_doppler)
    2225        
    2226         return res
    2227    
    2228     @asaplog_post_dec
    2229     def get_first_rowno_by_if(self, ifno):
    2230         found = False
    2231         for irow in xrange(self.nrow()):
    2232             if (self.getif(irow) == ifno):
    2233                 res = irow
    2234                 found = True
    2235                 break
    2236 
    2237         if not found: raise RuntimeError("No valid spw.")
    2238        
    2239         return res
    2240 
    2241     @asaplog_post_dec
    2242     def _get_coordinate_list(self):
    2243         res = []
    2244         spws = self.getifnos()
    2245         for spw in spws:
    2246             elem = {}
    2247             elem['if']    = spw
    2248             elem['coord'] = self.get_coordinate(self.get_first_rowno_by_if(spw))
    2249             res.append(elem)
    2250 
    2251         return res
    2252    
    2253     @asaplog_post_dec
    22541473    def parse_maskexpr(self, maskstring):
    22551474        """
     
    22821501            maskstring = str(valid_ifs)[1:-1]
    22831502        ## split each selection "IF range[:CHAN range]"
    2284         # split maskstring by "<spaces>,<spaces>"
    2285         comma_sep = re.compile('\s*,\s*')
    2286         sellist = comma_sep.split(maskstring)
    2287         # separator by "<spaces>:<spaces>"
    2288         collon_sep = re.compile('\s*:\s*')
     1503        sellist = maskstring.split(',')
    22891504        for currselstr in sellist:
    2290             selset = collon_sep.split(currselstr)
     1505            selset = currselstr.split(':')
    22911506            # spw and mask string (may include ~, < or >)
    22921507            spwmasklist = self._parse_selection(selset[0], typestr='integer',
     
    24221637        if smode == 'r':
    24231638            minidx = 0
    2424             maxidx = self.nrow()-1
     1639            maxidx = self.nrow()
    24251640        else:
    24261641            idx = getattr(self,"get"+mode+"nos")()
     
    24281643            maxidx = max(idx)
    24291644            del idx
    2430         # split selexpr by "<spaces>,<spaces>"
    2431         comma_sep = re.compile('\s*,\s*')
    2432         sellist = comma_sep.split(selexpr)
     1645        sellist = selexpr.split(',')
    24331646        idxlist = []
    24341647        for currselstr in sellist:
     
    24381651            for thelist in currlist:
    24391652                idxlist += range(thelist[0],thelist[1]+1)
    2440         # remove duplicated elements after first ones
    2441         for i in reversed(xrange(len(idxlist))):
    2442             if idxlist.index(idxlist[i]) < i:
    2443                 idxlist.pop(i)
    2444 
    2445         # remove elements outside range [minidx, maxidx] for smode='r'
    2446         if smode == 'r':
    2447             for i in reversed(xrange(len(idxlist))):
    2448                 if (idxlist[i] < minidx) or (idxlist[i] > maxidx):
    2449                     idxlist.pop(i)
    2450        
    24511653        msg = "Selected %s: %s" % (mode.upper()+"NO", str(idxlist))
    24521654        asaplog.push(msg)
     
    24741676            --> returns [[0.,2.5],[5.0,7.0],[9.,9.]]
    24751677        """
    2476         # split selstr by '<spaces>;<spaces>'
    2477         semi_sep = re.compile('\s*;\s*')
    2478         selgroups = semi_sep.split(selstr)
     1678        selgroups = selstr.split(';')
    24791679        sellists = []
    24801680        if typestr.lower().startswith('int'):
     
    24851685       
    24861686        for currsel in  selgroups:
    2487             if currsel.strip() == '*' or len(currsel.strip()) == 0:
    2488                 minsel = minval
    2489                 maxsel = maxval
    24901687            if currsel.find('~') > 0:
    24911688                # val0 <= x <= val1
    24921689                minsel = formatfunc(currsel.split('~')[0].strip())
    2493                 maxsel = formatfunc(currsel.split('~')[1].strip())
     1690                maxsel = formatfunc(currsel.split('~')[1].strip()) 
    24941691            elif currsel.strip().find('<=') > -1:
    24951692                bound = currsel.split('<=')
     
    27101907
    27111908    @asaplog_post_dec
    2712     def history(self, filename=None, nrows=-1, start=0):
     1909    def history(self, filename=None):
    27131910        """\
    27141911        Print the history. Optionally to a file.
     
    27191916
    27201917        """
    2721         n = self._historylength()
    2722         if nrows == -1:
    2723             nrows = n
    2724         if start+nrows > n:
    2725             nrows = nrows-start
    2726         if n > 1000 and nrows == n:
    2727             nrows = 1000
    2728             start = n-1000
    2729             asaplog.push("Warning: History has {0} entries. Displaying last "
    2730                          "1000".format(n))
    2731         hist = list(self._gethistory(nrows, start))
     1918        hist = list(self._gethistory())
    27321919        out = "-"*80
    27331920        for h in hist:
    2734             if not h.strip():
    2735                 continue
    2736             if h.find("---") >-1:
    2737                 continue
     1921            if h.startswith("---"):
     1922                out = "\n".join([out, h])
    27381923            else:
    27391924                items = h.split("##")
     
    27481933                    s = i.split("=")
    27491934                    out += "\n   %s = %s" % (s[0], s[1])
    2750                 out = "\n".join([out, "*"*80])
     1935                out = "\n".join([out, "-"*80])
    27511936        if filename is not None:
    27521937            if filename is "":
    27531938                filename = 'scantable_history.txt'
     1939            import os
    27541940            filename = os.path.expandvars(os.path.expanduser(filename))
    27551941            if not os.path.isdir(filename):
     
    27661952    #
    27671953    @asaplog_post_dec
    2768     def average_time(self, mask=None, scanav=False, weight='tint', align=False,
    2769                      avmode="NONE"):
     1954    def average_time(self, mask=None, scanav=False, weight='tint', align=False):
    27701955        """\
    27711956        Return the (time) weighted average of a scan. Scans will be averaged
     
    27951980            align:    align the spectra in velocity before averaging. It takes
    27961981                      the time of the first spectrum as reference time.
    2797             avmode:   'SOURCE' - also select by source name -  or
    2798                       'NONE' (default). Not applicable for scanav=True or
    2799                       weight=median
    28001982
    28011983        Example::
     
    28081990        weight = weight or 'TINT'
    28091991        mask = mask or ()
    2810         scanav = (scanav and 'SCAN') or avmode.upper()
     1992        scanav = (scanav and 'SCAN') or 'NONE'
    28111993        scan = (self, )
    28121994
    28131995        if align:
    28141996            scan = (self.freq_align(insitu=False), )
    2815             asaplog.push("Note: Alignment is don on a source-by-source basis")
    2816             asaplog.push("Note: Averaging (by default) is not")
    2817             # we need to set it to SOURCE averaging here           
    28181997        s = None
    28191998        if weight.upper() == 'MEDIAN':
     
    33602539            raise RuntimeError(msg)
    33612540
    3362     @asaplog_post_dec
    3363     def apply_bltable(self, insitu=None, retfitres=None, inbltable=None, outbltable=None, overwrite=None):
    3364         """\
    3365         Subtract baseline based on parameters written in Baseline Table.
    3366 
    3367         Parameters:
    3368             insitu:        if True, baseline fitting/subtraction is done
    3369                            in-situ. If False, a new scantable with
    3370                            baseline subtracted is returned. Actually,
    3371                            format of the returned value depends on both
    3372                            insitu and retfitres (see below).
    3373                            The default is taken from .asaprc (False)
    3374             retfitres:     if True, the results of baseline fitting (i.e.,
    3375                            coefficients and rms) are returned.
    3376                            default is False.
    3377                            The format of the returned value of this
    3378                            function varies as follows:
    3379                            (1) in case insitu=True and retfitres=True:
    3380                                fitting result.
    3381                            (2) in case insitu=True and retfitres=False:
    3382                                None.
    3383                            (3) in case insitu=False and retfitres=True:
    3384                                a dictionary containing a new scantable
    3385                                (with baseline subtracted) and the fitting
    3386                                results.
    3387                            (4) in case insitu=False and retfitres=False:
    3388                                a new scantable (with baseline subtracted).
    3389             inbltable:     name of input baseline table. The row number of
    3390                            scantable and that of inbltable must be
    3391                            identical.
    3392             outbltable:    name of output baseline table where baseline
    3393                            parameters and fitting results recorded.
    3394                            default is ''(no output).
    3395             overwrite:     if True when an existing baseline table is
    3396                            specified for outbltable, overwrites it.
    3397                            Otherwise there is no harm.
    3398                            default is False.
    3399         """
    3400 
    3401         try:
    3402             varlist = vars()
    3403             if retfitres      is None: retfitres      = False
    3404             if inbltable      is None: raise ValueError("bltable missing.")
    3405             if outbltable     is None: outbltable     = ''
    3406             if overwrite      is None: overwrite      = False
    3407 
    3408             if insitu is None: insitu = rcParams['insitu']
    3409             if insitu:
    3410                 workscan = self
    3411             else:
    3412                 workscan = self.copy()
    3413 
    3414             sres = workscan._apply_bltable(inbltable,
    3415                                            retfitres,
    3416                                            outbltable,
    3417                                            os.path.exists(outbltable),
    3418                                            overwrite)
    3419             if retfitres: res = parse_fitresult(sres)
    3420 
    3421             workscan._add_history('apply_bltable', varlist)
    3422 
    3423             if insitu:
    3424                 self._assign(workscan)
    3425                 if retfitres:
    3426                     return res
    3427                 else:
    3428                     return None
    3429             else:
    3430                 if retfitres:
    3431                     return {'scantable': workscan, 'fitresults': res}
    3432                 else:
    3433                     return workscan
    3434        
    3435         except RuntimeError, e:
    3436             raise_fitting_failure_exception(e)
    3437 
    3438     @asaplog_post_dec
    3439     def sub_baseline(self, insitu=None, retfitres=None, blinfo=None, bltable=None, overwrite=None):
    3440         """\
    3441         Subtract baseline based on parameters written in the input list.
    3442 
    3443         Parameters:
    3444             insitu:        if True, baseline fitting/subtraction is done
    3445                            in-situ. If False, a new scantable with
    3446                            baseline subtracted is returned. Actually,
    3447                            format of the returned value depends on both
    3448                            insitu and retfitres (see below).
    3449                            The default is taken from .asaprc (False)
    3450             retfitres:     if True, the results of baseline fitting (i.e.,
    3451                            coefficients and rms) are returned.
    3452                            default is False.
    3453                            The format of the returned value of this
    3454                            function varies as follows:
    3455                            (1) in case insitu=True and retfitres=True:
    3456                                fitting result.
    3457                            (2) in case insitu=True and retfitres=False:
    3458                                None.
    3459                            (3) in case insitu=False and retfitres=True:
    3460                                a dictionary containing a new scantable
    3461                                (with baseline subtracted) and the fitting
    3462                                results.
    3463                            (4) in case insitu=False and retfitres=False:
    3464                                a new scantable (with baseline subtracted).
    3465             blinfo:        baseline parameter set stored in a dictionary
    3466                            or a list of dictionary. Each dictionary
    3467                            corresponds to each spectrum and must contain
    3468                            the following keys and values:
    3469                              'row': row number,
    3470                              'blfunc': function name. available ones include
    3471                                        'poly', 'chebyshev', 'cspline' and
    3472                                        'sinusoid',
    3473                              'order': maximum order of polynomial. needed
    3474                                       if blfunc='poly' or 'chebyshev',
    3475                              'npiece': number or piecewise polynomial.
    3476                                        needed if blfunc='cspline',
    3477                              'nwave': a list of sinusoidal wave numbers.
    3478                                       needed if blfunc='sinusoid', and
    3479                              'masklist': min-max windows for channel mask.
    3480                                          the specified ranges will be used
    3481                                          for fitting.
    3482             bltable:       name of output baseline table where baseline
    3483                            parameters and fitting results recorded.
    3484                            default is ''(no output).
    3485             overwrite:     if True when an existing baseline table is
    3486                            specified for bltable, overwrites it.
    3487                            Otherwise there is no harm.
    3488                            default is False.
    3489                            
    3490         Example:
    3491             sub_baseline(blinfo=[{'row':0, 'blfunc':'poly', 'order':5,
    3492                                   'masklist':[[10,350],[352,510]]},
    3493                                  {'row':1, 'blfunc':'cspline', 'npiece':3,
    3494                                   'masklist':[[3,16],[19,404],[407,511]]}
    3495                                   ])
    3496 
    3497                 the first spectrum (row=0) will be fitted with polynomial
    3498                 of order=5 and the next one (row=1) will be fitted with cubic
    3499                 spline consisting of 3 pieces.
    3500         """
    3501 
    3502         try:
    3503             varlist = vars()
    3504             if retfitres      is None: retfitres      = False
    3505             if blinfo         is None: blinfo         = []
    3506             if bltable        is None: bltable        = ''
    3507             if overwrite      is None: overwrite      = False
    3508 
    3509             if insitu is None: insitu = rcParams['insitu']
    3510             if insitu:
    3511                 workscan = self
    3512             else:
    3513                 workscan = self.copy()
    3514 
    3515             nrow = workscan.nrow()
    3516 
    3517             in_blinfo = pack_blinfo(blinfo=blinfo, maxirow=nrow)
    3518 
    3519             sres = workscan._sub_baseline(in_blinfo,
    3520                                           retfitres,
    3521                                           bltable,
    3522                                           os.path.exists(bltable),
    3523                                           overwrite)
    3524             if retfitres: res = parse_fitresult(sres)
    3525            
    3526             workscan._add_history('sub_baseline', varlist)
    3527 
    3528             if insitu:
    3529                 self._assign(workscan)
    3530                 if retfitres:
    3531                     return res
    3532                 else:
    3533                     return None
    3534             else:
    3535                 if retfitres:
    3536                     return {'scantable': workscan, 'fitresults': res}
    3537                 else:
    3538                     return workscan
    3539 
    3540         except RuntimeError, e:
    3541             raise_fitting_failure_exception(e)
    3542 
    3543     @asaplog_post_dec
    3544     def calc_aic(self, value=None, blfunc=None, order=None, mask=None,
    3545                  whichrow=None, uselinefinder=None, edge=None,
    3546                  threshold=None, chan_avg_limit=None):
    3547         """\
    3548         Calculates and returns model selection criteria for a specified
    3549         baseline model and a given spectrum data.
    3550         Available values include Akaike Information Criterion (AIC), the
    3551         corrected Akaike Information Criterion (AICc) by Sugiura(1978),
    3552         Bayesian Information Criterion (BIC) and the Generalised Cross
    3553         Validation (GCV).
    3554 
    3555         Parameters:
    3556             value:         name of model selection criteria to calculate.
    3557                            available ones include 'aic', 'aicc', 'bic' and
    3558                            'gcv'. default is 'aicc'.
    3559             blfunc:        baseline function name. available ones include
    3560                            'chebyshev', 'cspline' and 'sinusoid'.
    3561                            default is 'chebyshev'.
    3562             order:         parameter for basline function. actually stands for
    3563                            order of polynomial (order) for 'chebyshev',
    3564                            number of spline pieces (npiece) for 'cspline' and
    3565                            maximum wave number for 'sinusoid', respectively.
    3566                            default is 5 (which is also the default order value
    3567                            for [auto_]chebyshev_baseline()).
    3568             mask:          an optional mask. default is [].
    3569             whichrow:      row number. default is 0 (the first row)
    3570             uselinefinder: use sd.linefinder() to flag out line regions
    3571                            default is True.
    3572             edge:           an optional number of channel to drop at
    3573                             the edge of spectrum. If only one value is
    3574                             specified, the same number will be dropped
    3575                             from both sides of the spectrum. Default
    3576                             is to keep all channels. Nested tuples
    3577                             represent individual edge selection for
    3578                             different IFs (a number of spectral channels
    3579                             can be different)
    3580                             default is (0, 0).
    3581             threshold:      the threshold used by line finder. It is
    3582                             better to keep it large as only strong lines
    3583                             affect the baseline solution.
    3584                             default is 3.
    3585             chan_avg_limit: a maximum number of consequtive spectral
    3586                             channels to average during the search of
    3587                             weak and broad lines. The default is no
    3588                             averaging (and no search for weak lines).
    3589                             If such lines can affect the fitted baseline
    3590                             (e.g. a high order polynomial is fitted),
    3591                             increase this parameter (usually values up
    3592                             to 8 are reasonable). Most users of this
    3593                             method should find the default value sufficient.
    3594                             default is 1.
    3595 
    3596         Example:
    3597             aic = scan.calc_aic(blfunc='chebyshev', order=5, whichrow=0)
    3598         """
    3599 
    3600         try:
    3601             varlist = vars()
    3602 
    3603             if value          is None: value          = 'aicc'
    3604             if blfunc         is None: blfunc         = 'chebyshev'
    3605             if order          is None: order          = 5
    3606             if mask           is None: mask           = []
    3607             if whichrow       is None: whichrow       = 0
    3608             if uselinefinder  is None: uselinefinder  = True
    3609             if edge           is None: edge           = (0, 0)
    3610             if threshold      is None: threshold      = 3
    3611             if chan_avg_limit is None: chan_avg_limit = 1
    3612 
    3613             return self._calc_aic(value, blfunc, order, mask,
    3614                                   whichrow, uselinefinder, edge,
    3615                                   threshold, chan_avg_limit)
    3616            
    3617         except RuntimeError, e:
    3618             raise_fitting_failure_exception(e)
    3619 
    3620     @asaplog_post_dec
    3621     def sinusoid_baseline(self, mask=None, applyfft=None,
     2541
     2542    @asaplog_post_dec
     2543    def sinusoid_baseline(self, insitu=None, mask=None, applyfft=None,
    36222544                          fftmethod=None, fftthresh=None,
    3623                           addwn=None, rejwn=None,
    3624                           insitu=None,
    3625                           clipthresh=None, clipniter=None,
    3626                           plot=None,
    3627                           getresidual=None,
    3628                           showprogress=None, minnrow=None,
    3629                           outlog=None,
    3630                           blfile=None, csvformat=None,
    3631                           bltable=None):
     2545                          addwn=None, rejwn=None, clipthresh=None,
     2546                          clipniter=None, plot=None,
     2547                          getresidual=None, showprogress=None,
     2548                          minnrow=None, outlog=None, blfile=None, csvformat=None):
    36322549        """\
    36332550        Return a scan which has been baselined (all rows) with sinusoidal
     
    36352552
    36362553        Parameters:
     2554            insitu:        if False a new scantable is returned.
     2555                           Otherwise, the scaling is done in-situ
     2556                           The default is taken from .asaprc (False)
    36372557            mask:          an optional mask
    36382558            applyfft:      if True use some method, such as FFT, to find
     
    36662586                           wave numbers which are specified both in addwn
    36672587                           and rejwn will NOT be used. default is [].
    3668             insitu:        if False a new scantable is returned.
    3669                            Otherwise, the scaling is done in-situ
    3670                            The default is taken from .asaprc (False)
    36712588            clipthresh:    Clipping threshold. (default is 3.0, unit: sigma)
    36722589            clipniter:     maximum number of iteration of 'clipthresh'-sigma
     
    36882605                           (default is '': no file/logger output)
    36892606            csvformat:     if True blfile is csv-formatted, default is False.
    3690             bltable:       name of a baseline table where fitting results
    3691                            (coefficients, rms, etc.) are to be written.
    3692                            if given, fitting results will NOT be output to
    3693                            scantable (insitu=True) or None will be
    3694                            returned (insitu=False).
    3695                            (default is "": no table output)
    36962607
    36972608        Example:
     
    37152626                workscan = self.copy()
    37162627           
     2628            #if mask          is None: mask          = [True for i in xrange(workscan.nchan())]
    37172629            if mask          is None: mask          = []
    37182630            if applyfft      is None: applyfft      = True
     
    37302642            if blfile        is None: blfile        = ''
    37312643            if csvformat     is None: csvformat     = False
    3732             if bltable       is None: bltable       = ''
    3733 
    3734             sapplyfft = 'true' if applyfft else 'false'
    3735             fftinfo = ','.join([sapplyfft, fftmethod.lower(), str(fftthresh).lower()])
    3736 
    3737             scsvformat = 'T' if csvformat else 'F'
     2644
     2645            if csvformat:
     2646                scsvformat = "T"
     2647            else:
     2648                scsvformat = "F"
    37382649
    37392650            #CURRENTLY, PLOT=true is UNAVAILABLE UNTIL sinusoidal fitting is implemented as a fitter method.
    3740             workscan._sinusoid_baseline(mask,
    3741                                         fftinfo,
    3742                                         #applyfft, fftmethod.lower(),
    3743                                         #str(fftthresh).lower(),
     2651            workscan._sinusoid_baseline(mask, applyfft, fftmethod.lower(),
     2652                                        str(fftthresh).lower(),
    37442653                                        workscan._parse_wn(addwn),
    37452654                                        workscan._parse_wn(rejwn),
     
    37482657                                        pack_progress_params(showprogress,
    37492658                                                             minnrow),
    3750                                         outlog, scsvformat+blfile,
    3751                                         bltable)
     2659                                        outlog, scsvformat+blfile)
    37522660            workscan._add_history('sinusoid_baseline', varlist)
    3753 
    3754             if bltable == '':
    3755                 if insitu:
    3756                     self._assign(workscan)
    3757                 else:
    3758                     return workscan
    3759             else:
    3760                 if not insitu:
    3761                     return None
     2661           
     2662            if insitu:
     2663                self._assign(workscan)
     2664            else:
     2665                return workscan
    37622666           
    37632667        except RuntimeError, e:
     
    37662670
    37672671    @asaplog_post_dec
    3768     def auto_sinusoid_baseline(self, mask=None, applyfft=None,
     2672    def auto_sinusoid_baseline(self, insitu=None, mask=None, applyfft=None,
    37692673                               fftmethod=None, fftthresh=None,
    3770                                addwn=None, rejwn=None,
    3771                                insitu=None,
    3772                                clipthresh=None, clipniter=None,
    3773                                edge=None, threshold=None, chan_avg_limit=None,
    3774                                plot=None,
    3775                                getresidual=None,
    3776                                showprogress=None, minnrow=None,
    3777                                outlog=None,
    3778                                blfile=None, csvformat=None,
    3779                                bltable=None):
     2674                               addwn=None, rejwn=None, clipthresh=None,
     2675                               clipniter=None, edge=None, threshold=None,
     2676                               chan_avg_limit=None, plot=None,
     2677                               getresidual=None, showprogress=None,
     2678                               minnrow=None, outlog=None, blfile=None, csvformat=None):
    37802679        """\
    37812680        Return a scan which has been baselined (all rows) with sinusoidal
     
    37852684
    37862685        Parameters:
     2686            insitu:         if False a new scantable is returned.
     2687                            Otherwise, the scaling is done in-situ
     2688                            The default is taken from .asaprc (False)
    37872689            mask:           an optional mask retreived from scantable
    37882690            applyfft:       if True use some method, such as FFT, to find
     
    38162718                            wave numbers which are specified both in addwn
    38172719                            and rejwn will NOT be used. default is [].
    3818             insitu:         if False a new scantable is returned.
    3819                             Otherwise, the scaling is done in-situ
    3820                             The default is taken from .asaprc (False)
    38212720            clipthresh:     Clipping threshold. (default is 3.0, unit: sigma)
    38222721            clipniter:      maximum number of iteration of 'clipthresh'-sigma
     
    38582757                            (default is "": no file/logger output)
    38592758            csvformat:      if True blfile is csv-formatted, default is False.
    3860             bltable:        name of a baseline table where fitting results
    3861                             (coefficients, rms, etc.) are to be written.
    3862                             if given, fitting results will NOT be output to
    3863                             scantable (insitu=True) or None will be
    3864                             returned (insitu=False).
    3865                             (default is "": no table output)
    38662759
    38672760        Example:
     
    38822775                workscan = self.copy()
    38832776           
     2777            #if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
    38842778            if mask           is None: mask           = []
    38852779            if applyfft       is None: applyfft       = True
     
    39002794            if blfile         is None: blfile         = ''
    39012795            if csvformat      is None: csvformat      = False
    3902             if bltable        is None: bltable        = ''
    3903 
    3904             sapplyfft = 'true' if applyfft else 'false'
    3905             fftinfo = ','.join([sapplyfft, fftmethod.lower(), str(fftthresh).lower()])
    3906 
    3907             scsvformat = 'T' if csvformat else 'F'
     2796
     2797            if csvformat:
     2798                scsvformat = "T"
     2799            else:
     2800                scsvformat = "F"
    39082801
    39092802            #CURRENTLY, PLOT=true is UNAVAILABLE UNTIL sinusoidal fitting is implemented as a fitter method.
    3910             workscan._auto_sinusoid_baseline(mask,
    3911                                              fftinfo,
     2803            workscan._auto_sinusoid_baseline(mask, applyfft,
     2804                                             fftmethod.lower(),
     2805                                             str(fftthresh).lower(),
    39122806                                             workscan._parse_wn(addwn),
    39132807                                             workscan._parse_wn(rejwn),
     
    39182812                                             pack_progress_params(showprogress,
    39192813                                                                  minnrow),
    3920                                              outlog, scsvformat+blfile, bltable)
     2814                                             outlog, scsvformat+blfile)
    39212815            workscan._add_history("auto_sinusoid_baseline", varlist)
    3922 
    3923             if bltable == '':
    3924                 if insitu:
    3925                     self._assign(workscan)
    3926                 else:
    3927                     return workscan
    3928             else:
    3929                 if not insitu:
    3930                     return None
     2816           
     2817            if insitu:
     2818                self._assign(workscan)
     2819            else:
     2820                return workscan
    39312821           
    39322822        except RuntimeError, e:
     
    39342824
    39352825    @asaplog_post_dec
    3936     def cspline_baseline(self, mask=None, npiece=None, insitu=None,
     2826    def cspline_baseline(self, insitu=None, mask=None, npiece=None,
    39372827                         clipthresh=None, clipniter=None, plot=None,
    39382828                         getresidual=None, showprogress=None, minnrow=None,
    3939                          outlog=None, blfile=None, csvformat=None,
    3940                          bltable=None):
     2829                         outlog=None, blfile=None, csvformat=None):
    39412830        """\
    39422831        Return a scan which has been baselined (all rows) by cubic spline
     
    39442833
    39452834        Parameters:
    3946             mask:         An optional mask
    3947             npiece:       Number of pieces. (default is 2)
    39482835            insitu:       If False a new scantable is returned.
    39492836                          Otherwise, the scaling is done in-situ
    39502837                          The default is taken from .asaprc (False)
     2838            mask:         An optional mask
     2839            npiece:       Number of pieces. (default is 2)
    39512840            clipthresh:   Clipping threshold. (default is 3.0, unit: sigma)
    39522841            clipniter:    maximum number of iteration of 'clipthresh'-sigma
     
    39682857                          (default is "": no file/logger output)
    39692858            csvformat:    if True blfile is csv-formatted, default is False.
    3970             bltable:      name of a baseline table where fitting results
    3971                           (coefficients, rms, etc.) are to be written.
    3972                           if given, fitting results will NOT be output to
    3973                           scantable (insitu=True) or None will be
    3974                           returned (insitu=False).
    3975                           (default is "": no table output)
    39762859
    39772860        Example:
     
    39952878                workscan = self.copy()
    39962879
     2880            #if mask         is None: mask         = [True for i in xrange(workscan.nchan())]
    39972881            if mask         is None: mask         = []
    39982882            if npiece       is None: npiece       = 2
     
    40052889            if outlog       is None: outlog       = False
    40062890            if blfile       is None: blfile       = ''
    4007             if csvformat    is None: csvformat    = False
    4008             if bltable      is None: bltable      = ''
    4009 
    4010             scsvformat = 'T' if csvformat else 'F'
     2891            if csvformat     is None: csvformat     = False
     2892
     2893            if csvformat:
     2894                scsvformat = "T"
     2895            else:
     2896                scsvformat = "F"
    40112897
    40122898            #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method.
    4013             workscan._cspline_baseline(mask, npiece,
    4014                                        clipthresh, clipniter,
     2899            workscan._cspline_baseline(mask, npiece, clipthresh, clipniter,
    40152900                                       getresidual,
    40162901                                       pack_progress_params(showprogress,
    40172902                                                            minnrow),
    4018                                        outlog, scsvformat+blfile,
    4019                                        bltable)
     2903                                       outlog, scsvformat+blfile)
    40202904            workscan._add_history("cspline_baseline", varlist)
    4021 
    4022             if bltable == '':
    4023                 if insitu:
    4024                     self._assign(workscan)
    4025                 else:
    4026                     return workscan
    4027             else:
    4028                 if not insitu:
    4029                     return None
     2905           
     2906            if insitu:
     2907                self._assign(workscan)
     2908            else:
     2909                return workscan
    40302910           
    40312911        except RuntimeError, e:
     
    40332913
    40342914    @asaplog_post_dec
    4035     def auto_cspline_baseline(self, mask=None, npiece=None, insitu=None,
     2915    def auto_cspline_baseline(self, insitu=None, mask=None, npiece=None,
    40362916                              clipthresh=None, clipniter=None,
    40372917                              edge=None, threshold=None, chan_avg_limit=None,
    40382918                              getresidual=None, plot=None,
    40392919                              showprogress=None, minnrow=None, outlog=None,
    4040                               blfile=None, csvformat=None, bltable=None):
     2920                              blfile=None, csvformat=None):
    40412921        """\
    40422922        Return a scan which has been baselined (all rows) by cubic spline
     
    40462926
    40472927        Parameters:
    4048             mask:           an optional mask retreived from scantable
    4049             npiece:         Number of pieces. (default is 2)
    40502928            insitu:         if False a new scantable is returned.
    40512929                            Otherwise, the scaling is done in-situ
    40522930                            The default is taken from .asaprc (False)
     2931            mask:           an optional mask retreived from scantable
     2932            npiece:         Number of pieces. (default is 2)
    40532933            clipthresh:     Clipping threshold. (default is 3.0, unit: sigma)
    40542934            clipniter:      maximum number of iteration of 'clipthresh'-sigma
     
    40902970                            (default is "": no file/logger output)
    40912971            csvformat:      if True blfile is csv-formatted, default is False.
    4092             bltable:        name of a baseline table where fitting results
    4093                             (coefficients, rms, etc.) are to be written.
    4094                             if given, fitting results will NOT be output to
    4095                             scantable (insitu=True) or None will be
    4096                             returned (insitu=False).
    4097                             (default is "": no table output)
    40982972
    40992973        Example:
     
    41293003            if blfile         is None: blfile         = ''
    41303004            if csvformat      is None: csvformat      = False
    4131             if bltable        is None: bltable        = ''
    4132 
    4133             scsvformat = 'T' if csvformat else 'F'
     3005
     3006            if csvformat:
     3007                scsvformat = "T"
     3008            else:
     3009                scsvformat = "F"
    41343010
    41353011            #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method.
    4136             workscan._auto_cspline_baseline(mask, npiece,
    4137                                             clipthresh, clipniter,
     3012            workscan._auto_cspline_baseline(mask, npiece, clipthresh,
     3013                                            clipniter,
    41383014                                            normalise_edge_param(edge),
    41393015                                            threshold,
     
    41413017                                            pack_progress_params(showprogress,
    41423018                                                                 minnrow),
    4143                                             outlog,
    4144                                             scsvformat+blfile,
    4145                                             bltable)
     3019                                            outlog, scsvformat+blfile)
    41463020            workscan._add_history("auto_cspline_baseline", varlist)
    4147 
    4148             if bltable == '':
    4149                 if insitu:
    4150                     self._assign(workscan)
    4151                 else:
    4152                     return workscan
    4153             else:
    4154                 if not insitu:
    4155                     return None
     3021           
     3022            if insitu:
     3023                self._assign(workscan)
     3024            else:
     3025                return workscan
    41563026           
    41573027        except RuntimeError, e:
     
    41593029
    41603030    @asaplog_post_dec
    4161     def chebyshev_baseline(self, mask=None, order=None, insitu=None,
     3031    def chebyshev_baseline(self, insitu=None, mask=None, order=None,
    41623032                           clipthresh=None, clipniter=None, plot=None,
    41633033                           getresidual=None, showprogress=None, minnrow=None,
    4164                            outlog=None, blfile=None, csvformat=None,
    4165                            bltable=None):
     3034                           outlog=None, blfile=None, csvformat=None):
    41663035        """\
    41673036        Return a scan which has been baselined (all rows) by Chebyshev polynomials.
    41683037
    41693038        Parameters:
    4170             mask:         An optional mask
    4171             order:        the maximum order of Chebyshev polynomial (default is 5)
    41723039            insitu:       If False a new scantable is returned.
    41733040                          Otherwise, the scaling is done in-situ
    41743041                          The default is taken from .asaprc (False)
     3042            mask:         An optional mask
     3043            order:        the maximum order of Chebyshev polynomial (default is 5)
    41753044            clipthresh:   Clipping threshold. (default is 3.0, unit: sigma)
    41763045            clipniter:    maximum number of iteration of 'clipthresh'-sigma
     
    41923061                          (default is "": no file/logger output)
    41933062            csvformat:    if True blfile is csv-formatted, default is False.
    4194             bltable:      name of a baseline table where fitting results
    4195                           (coefficients, rms, etc.) are to be written.
    4196                           if given, fitting results will NOT be output to
    4197                           scantable (insitu=True) or None will be
    4198                           returned (insitu=False).
    4199                           (default is "": no table output)
    42003063
    42013064        Example:
     
    42193082                workscan = self.copy()
    42203083
     3084            #if mask         is None: mask         = [True for i in xrange(workscan.nchan())]
    42213085            if mask         is None: mask         = []
    42223086            if order        is None: order        = 5
     
    42293093            if outlog       is None: outlog       = False
    42303094            if blfile       is None: blfile       = ''
    4231             if csvformat    is None: csvformat    = False
    4232             if bltable      is None: bltable      = ''
    4233 
    4234             scsvformat = 'T' if csvformat else 'F'
     3095            if csvformat     is None: csvformat     = False
     3096
     3097            if csvformat:
     3098                scsvformat = "T"
     3099            else:
     3100                scsvformat = "F"
    42353101
    42363102            #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method.
    4237             workscan._chebyshev_baseline(mask, order,
    4238                                          clipthresh, clipniter,
     3103            workscan._chebyshev_baseline(mask, order, clipthresh, clipniter,
    42393104                                         getresidual,
    42403105                                         pack_progress_params(showprogress,
    42413106                                                              minnrow),
    4242                                          outlog, scsvformat+blfile,
    4243                                          bltable)
     3107                                         outlog, scsvformat+blfile)
    42443108            workscan._add_history("chebyshev_baseline", varlist)
    4245 
    4246             if bltable == '':
    4247                 if insitu:
    4248                     self._assign(workscan)
    4249                 else:
    4250                     return workscan
    4251             else:
    4252                 if not insitu:
    4253                     return None
     3109           
     3110            if insitu:
     3111                self._assign(workscan)
     3112            else:
     3113                return workscan
    42543114           
    42553115        except RuntimeError, e:
     
    42573117
    42583118    @asaplog_post_dec
    4259     def auto_chebyshev_baseline(self, mask=None, order=None, insitu=None,
     3119    def auto_chebyshev_baseline(self, insitu=None, mask=None, order=None,
    42603120                              clipthresh=None, clipniter=None,
    42613121                              edge=None, threshold=None, chan_avg_limit=None,
    42623122                              getresidual=None, plot=None,
    42633123                              showprogress=None, minnrow=None, outlog=None,
    4264                               blfile=None, csvformat=None, bltable=None):
     3124                              blfile=None, csvformat=None):
    42653125        """\
    42663126        Return a scan which has been baselined (all rows) by Chebyshev polynomials.
     
    42693129
    42703130        Parameters:
    4271             mask:           an optional mask retreived from scantable
    4272             order:          the maximum order of Chebyshev polynomial (default is 5)
    42733131            insitu:         if False a new scantable is returned.
    42743132                            Otherwise, the scaling is done in-situ
    42753133                            The default is taken from .asaprc (False)
     3134            mask:           an optional mask retreived from scantable
     3135            order:          the maximum order of Chebyshev polynomial (default is 5)
    42763136            clipthresh:     Clipping threshold. (default is 3.0, unit: sigma)
    42773137            clipniter:      maximum number of iteration of 'clipthresh'-sigma
     
    43133173                            (default is "": no file/logger output)
    43143174            csvformat:      if True blfile is csv-formatted, default is False.
    4315             bltable:        name of a baseline table where fitting results
    4316                             (coefficients, rms, etc.) are to be written.
    4317                             if given, fitting results will NOT be output to
    4318                             scantable (insitu=True) or None will be
    4319                             returned (insitu=False).
    4320                             (default is "": no table output)
    43213175
    43223176        Example:
     
    43373191                workscan = self.copy()
    43383192           
     3193            #if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
    43393194            if mask           is None: mask           = []
    43403195            if order          is None: order          = 5
     
    43513206            if blfile         is None: blfile         = ''
    43523207            if csvformat      is None: csvformat      = False
    4353             if bltable        is None: bltable        = ''
    4354 
    4355             scsvformat = 'T' if csvformat else 'F'
     3208
     3209            if csvformat:
     3210                scsvformat = "T"
     3211            else:
     3212                scsvformat = "F"
    43563213
    43573214            #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method.
    4358             workscan._auto_chebyshev_baseline(mask, order,
    4359                                               clipthresh, clipniter,
     3215            workscan._auto_chebyshev_baseline(mask, order, clipthresh,
     3216                                              clipniter,
    43603217                                              normalise_edge_param(edge),
    43613218                                              threshold,
     
    43633220                                              pack_progress_params(showprogress,
    43643221                                                                   minnrow),
    4365                                               outlog, scsvformat+blfile,
    4366                                               bltable)
     3222                                              outlog, scsvformat+blfile)
    43673223            workscan._add_history("auto_chebyshev_baseline", varlist)
    4368 
    4369             if bltable == '':
    4370                 if insitu:
    4371                     self._assign(workscan)
    4372                 else:
    4373                     return workscan
    4374             else:
    4375                 if not insitu:
    4376                     return None
     3224           
     3225            if insitu:
     3226                self._assign(workscan)
     3227            else:
     3228                return workscan
    43773229           
    43783230        except RuntimeError, e:
     
    43803232
    43813233    @asaplog_post_dec
    4382     def poly_baseline(self, mask=None, order=None, insitu=None,
    4383                       clipthresh=None, clipniter=None, plot=None,
     3234    def poly_baseline(self, mask=None, order=None, insitu=None, plot=None,
    43843235                      getresidual=None, showprogress=None, minnrow=None,
    4385                       outlog=None, blfile=None, csvformat=None,
    4386                       bltable=None):
     3236                      outlog=None, blfile=None, csvformat=None):
    43873237        """\
    43883238        Return a scan which has been baselined (all rows) by a polynomial.
    43893239        Parameters:
    4390             mask:         an optional mask
    4391             order:        the order of the polynomial (default is 0)
    43923240            insitu:       if False a new scantable is returned.
    43933241                          Otherwise, the scaling is done in-situ
    43943242                          The default is taken from .asaprc (False)
    4395             clipthresh:   Clipping threshold. (default is 3.0, unit: sigma)
    4396             clipniter:    maximum number of iteration of 'clipthresh'-sigma
    4397                           clipping (default is 0)
     3243            mask:         an optional mask
     3244            order:        the order of the polynomial (default is 0)
    43983245            plot:         plot the fit and the residual. In this each
    43993246                          indivual fit has to be approved, by typing 'y'
     
    44113258                          (default is "": no file/logger output)
    44123259            csvformat:    if True blfile is csv-formatted, default is False.
    4413             bltable:      name of a baseline table where fitting results
    4414                           (coefficients, rms, etc.) are to be written.
    4415                           if given, fitting results will NOT be output to
    4416                           scantable (insitu=True) or None will be
    4417                           returned (insitu=False).
    4418                           (default is "": no table output)
    44193260
    44203261        Example:
     
    44343275                workscan = self.copy()
    44353276
     3277            #if mask         is None: mask         = [True for i in \
     3278            #                                           xrange(workscan.nchan())]
    44363279            if mask         is None: mask         = []
    44373280            if order        is None: order        = 0
    4438             if clipthresh   is None: clipthresh   = 3.0
    4439             if clipniter    is None: clipniter    = 0
    44403281            if plot         is None: plot         = False
    44413282            if getresidual  is None: getresidual  = True
     
    44433284            if minnrow      is None: minnrow      = 1000
    44443285            if outlog       is None: outlog       = False
    4445             if blfile       is None: blfile       = ''
     3286            if blfile       is None: blfile       = ""
    44463287            if csvformat    is None: csvformat    = False
    4447             if bltable      is None: bltable      = ''
    4448 
    4449             scsvformat = 'T' if csvformat else 'F'
     3288
     3289            if csvformat:
     3290                scsvformat = "T"
     3291            else:
     3292                scsvformat = "F"
    44503293
    44513294            if plot:
     
    45113354                    blf.close()
    45123355            else:
    4513                 workscan._poly_baseline(mask, order,
    4514                                         clipthresh, clipniter, #
    4515                                         getresidual,
     3356                workscan._poly_baseline(mask, order, getresidual,
    45163357                                        pack_progress_params(showprogress,
    45173358                                                             minnrow),
    4518                                         outlog, scsvformat+blfile,
    4519                                         bltable)  #
     3359                                        outlog, scsvformat+blfile)
    45203360           
    45213361            workscan._add_history("poly_baseline", varlist)
     
    45303370
    45313371    @asaplog_post_dec
    4532     def auto_poly_baseline(self, mask=None, order=None, insitu=None,
    4533                            clipthresh=None, clipniter=None,
    4534                            edge=None, threshold=None, chan_avg_limit=None,
    4535                            getresidual=None, plot=None,
    4536                            showprogress=None, minnrow=None, outlog=None,
    4537                            blfile=None, csvformat=None, bltable=None):
     3372    def auto_poly_baseline(self, mask=None, order=None, edge=None,
     3373                           threshold=None, chan_avg_limit=None,
     3374                           plot=None, insitu=None,
     3375                           getresidual=None, showprogress=None,
     3376                           minnrow=None, outlog=None, blfile=None, csvformat=None):
    45383377        """\
    45393378        Return a scan which has been baselined (all rows) by a polynomial.
     
    45423381
    45433382        Parameters:
    4544             mask:           an optional mask retreived from scantable
    4545             order:          the order of the polynomial (default is 0)
    45463383            insitu:         if False a new scantable is returned.
    45473384                            Otherwise, the scaling is done in-situ
    45483385                            The default is taken from .asaprc (False)
    4549             clipthresh:     Clipping threshold. (default is 3.0, unit: sigma)
    4550             clipniter:      maximum number of iteration of 'clipthresh'-sigma
    4551                             clipping (default is 0)
     3386            mask:           an optional mask retreived from scantable
     3387            order:          the order of the polynomial (default is 0)
    45523388            edge:           an optional number of channel to drop at
    45533389                            the edge of spectrum. If only one value is
     
    45853421                            (default is "": no file/logger output)
    45863422            csvformat:      if True blfile is csv-formatted, default is False.
    4587             bltable:        name of a baseline table where fitting results
    4588                             (coefficients, rms, etc.) are to be written.
    4589                             if given, fitting results will NOT be output to
    4590                             scantable (insitu=True) or None will be
    4591                             returned (insitu=False).
    4592                             (default is "": no table output)
    45933423
    45943424        Example:
     
    46063436                workscan = self.copy()
    46073437
     3438            #if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
    46083439            if mask           is None: mask           = []
    46093440            if order          is None: order          = 0
    4610             if clipthresh     is None: clipthresh     = 3.0
    4611             if clipniter      is None: clipniter      = 0
    46123441            if edge           is None: edge           = (0, 0)
    46133442            if threshold      is None: threshold      = 3
     
    46203449            if blfile         is None: blfile         = ''
    46213450            if csvformat      is None: csvformat      = False
    4622             if bltable        is None: bltable        = ''
    4623 
    4624             scsvformat = 'T' if csvformat else 'F'
     3451
     3452            if csvformat:
     3453                scsvformat = "T"
     3454            else:
     3455                scsvformat = "F"
    46253456
    46263457            edge = normalise_edge_param(edge)
     
    46923523                if outblfile: blf.close()
    46933524            else:
    4694                 workscan._auto_poly_baseline(mask, order,
    4695                                              clipthresh, clipniter,
    4696                                              edge, threshold,
     3525                workscan._auto_poly_baseline(mask, order, edge, threshold,
    46973526                                             chan_avg_limit, getresidual,
    46983527                                             pack_progress_params(showprogress,
    46993528                                                                  minnrow),
    4700                                              outlog, scsvformat+blfile,
    4701                                              bltable)
     3529                                             outlog, scsvformat+blfile)
     3530
    47023531            workscan._add_history("auto_poly_baseline", varlist)
    4703 
    4704             if bltable == '':
    4705                 if insitu:
    4706                     self._assign(workscan)
    4707                 else:
    4708                     return workscan
    4709             else:
    4710                 if not insitu:
    4711                     return None
     3532           
     3533            if insitu:
     3534                self._assign(workscan)
     3535            else:
     3536                return workscan
    47123537           
    47133538        except RuntimeError, e:
     
    48193644        self._math._setinsitu(insitu)
    48203645        varlist = vars()
    4821         s = scantable(self._math._unaryop(self, offset, "ADD", False, False))
     3646        s = scantable(self._math._unaryop(self, offset, "ADD", False))
    48223647        s._add_history("add", varlist)
    48233648        if insitu:
     
    48423667            tsys:        if True (default) then apply the operation to Tsys
    48433668                         as well as the data
     3669
    48443670        """
    48453671        if insitu is None: insitu = rcParams['insitu']
     
    48523678                                                         numpy.ndarray):
    48533679                from asapmath import _array2dOp
    4854                 s = _array2dOp( self, factor, "MUL", tsys, insitu, True )
     3680                s = _array2dOp( self, factor, "MUL", tsys, insitu )
    48553681            else:
    48563682                s = scantable( self._math._arrayop( self, factor,
    4857                                                     "MUL", tsys, True ) )
     3683                                                    "MUL", tsys ) )
    48583684        else:
    4859             s = scantable(self._math._unaryop(self, factor, "MUL", tsys, True ))
     3685            s = scantable(self._math._unaryop(self, factor, "MUL", tsys))
    48603686        s._add_history("scale", varlist)
    48613687        if insitu:
     
    49043730        self._add_history("set_sourcetype", varlist)
    49053731
    4906 
    4907     def set_sourcename(self, name):
    4908         varlist = vars()
    4909         self._setsourcename(name)
    4910         self._add_history("set_sourcename", varlist)
    4911 
    49123732    @asaplog_post_dec
    49133733    @preserve_selection
     
    49463766        s = None
    49473767        if mode.lower() == "paired":
    4948             from asap._asap import srctype
    49493768            sel = self.get_selection()
    4950             #sel.set_query("SRCTYPE==psoff")
    4951             sel.set_types(srctype.psoff)
     3769            sel.set_query("SRCTYPE==psoff")
    49523770            self.set_selection(sel)
    49533771            offs = self.copy()
    4954             #sel.set_query("SRCTYPE==pson")
    4955             sel.set_types(srctype.pson)
     3772            sel.set_query("SRCTYPE==pson")
    49563773            self.set_selection(sel)
    49573774            ons = self.copy()
     
    50703887            if other == 0.0:
    50713888                raise ZeroDivisionError("Dividing by zero is not recommended")
    5072             s = scantable(self._math._unaryop(self, other, mode, False, True))
     3889            s = scantable(self._math._unaryop(self, other, mode, False))
    50733890        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
    50743891            if isinstance(other[0], list) \
    50753892                    or isinstance(other[0], numpy.ndarray):
    50763893                from asapmath import _array2dOp
    5077                 s = _array2dOp(self, other, mode, False)
    5078             else:
    5079                 s = scantable(self._math._arrayop(self, other, mode, False, True))
     3894                s = _array2dOp( self, other, mode, False )
     3895            else:
     3896                s = scantable( self._math._arrayop( self, other,
     3897                                                    mode, False ) )
    50803898        else:
    50813899            raise TypeError("Other input is not a scantable or float value")
     
    51103928            self.set_selection(basesel+sel)
    51113929            nans = numpy.isnan(self._getspectrum(0))
    5112             if numpy.any(nans):
    5113                 bnans = [ bool(v) for v in nans]
    5114                 self.flag(bnans)
    5115        
    5116         self.set_selection(basesel)
     3930        if numpy.any(nans):
     3931            bnans = [ bool(v) for v in nans]
     3932            self.flag(bnans)
    51173933
    51183934    def get_row_selector(self, rowno):
Note: See TracChangeset for help on using the changeset viewer.