Changeset 2767 for trunk

Timestamp:

02/08/13 22:23:22 (12 years ago)

Author:

WataruKawasaki

Message:

New Development: Yes

JIRA Issue: Yes CAS-4794

Ready for Test: Yes

Interface Changes: No

What Interface Changed:

Test Programs:

Put in Release Notes: No

Module(s): sd

Description: functions to apply/write STBaselineTable in which baseline parameters stored.

Location:

trunk

Files:

• python/scantable.py (modified) (38 diffs)
• src/STBaselineEnum.h (modified) (1 diff)
• src/STBaselineTable.cpp (modified) (6 diffs)
• src/STBaselineTable.h (modified) (1 diff)
• src/Scantable.cpp (modified) (54 diffs)
• src/Scantable.h (modified) (13 diffs)
• src/ScantableWrapper.h (modified) (1 diff)
• src/python_Scantable.cpp (modified) (1 diff)

trunk/python/scantable.py

@@ -173 +173 @@
 def pack_progress_params(showprogress, minnrow):
     return str(showprogress).lower() + ',' + str(minnrow)
+
+def pack_blinfo(blinfo, maxirow):
+    """\
+    convert a dictionary or a list of dictionaries of baseline info
+    into a list of comma-separated strings. 
+    """
+    if isinstance(blinfo, dict):
+        res = do_pack_blinfo(blinfo, maxirow)
+        return [res] if res != '' else []
+    elif isinstance(blinfo, list) or isinstance(blinfo, tuple):
+        res = []
+        for i in xrange(len(blinfo)):
+            resi = do_pack_blinfo(blinfo[i], maxirow)
+            if resi != '':
+                res.append(resi)
+    return res
+
+def do_pack_blinfo(blinfo, maxirow):
+    """\
+    convert a dictionary of baseline info for a spectrum into
+    a comma-separated string. 
+    """
+    dinfo = {}
+    for key in ['row', 'blfunc', 'masklist']:
+        if blinfo.has_key(key):
+            val = blinfo[key]
+            if key == 'row':
+                irow = val
+            if isinstance(val, list) or isinstance(val, tuple):
+                slval = []
+                for i in xrange(len(val)):
+                    if isinstance(val[i], list) or isinstance(val[i], tuple):
+                        for j in xrange(len(val[i])):
+                            slval.append(str(val[i][j]))
+                    else:
+                        slval.append(str(val[i]))
+                sval = ",".join(slval)
+            else:
+                sval = str(val)
+
+            dinfo[key] = sval
+        else:
+            raise ValueError("'"+key+"' is missing in blinfo.")
+
+    if irow >= maxirow: return ''
+    
+    for key in ['order', 'npiece', 'nwave']:
+        if blinfo.has_key(key):
+            val = blinfo[key]
+            if isinstance(val, list) or isinstance(val, tuple):
+                slval = []
+                for i in xrange(len(val)):
+                    slval.append(str(val[i]))
+                sval = ",".join(slval)
+            else:
+                sval = str(val)
+            dinfo[key] = sval
+
+    blfunc = dinfo['blfunc']
+    fspec_keys = {'poly': 'order', 'chebyshev': 'order', 'cspline': 'npiece', 'sinusoid': 'nwave'}
+
+    fspec_key = fspec_keys[blfunc]
+    if not blinfo.has_key(fspec_key):
+        raise ValueError("'"+fspec_key+"' is missing in blinfo.")
+
+    clip_params_n = 0
+    for key in ['clipthresh', 'clipniter']:
+        if blinfo.has_key(key):
+            clip_params_n += 1
+            dinfo[key] = str(blinfo[key])
+
+    if clip_params_n == 0:
+        dinfo['clipthresh'] = '0.0'
+        dinfo['clipniter']  = '0'
+    elif clip_params_n != 2:
+        raise ValueError("both 'clipthresh' and 'clipniter' must be given for n-sigma clipping.")
+
+    lf_params_n = 0
+    for key in ['thresh', 'edge', 'chan_avg_limit']:
+        if blinfo.has_key(key):
+            lf_params_n += 1
+            val = blinfo[key]
+            if isinstance(val, list) or isinstance(val, tuple):
+                slval = []
+                for i in xrange(len(val)):
+                    slval.append(str(val[i]))
+                sval = ",".join(slval)
+            else:
+                sval = str(val)
+            dinfo[key] = sval
+
+    if lf_params_n == 3:
+        dinfo['use_linefinder'] = 'true'
+    elif lf_params_n == 1:
+        dinfo['use_linefinder'] = 'false'
+        dinfo['thresh']         = ''
+        dinfo['edge']           = ''
+        dinfo['chan_avg_limit'] = ''
+    else:
+        raise ValueError("all of 'thresh', 'edge' and 'chan_avg_limit' must be given to use linefinder.")
+    
+    slblinfo = [dinfo['row'], blfunc, dinfo[fspec_key], dinfo['masklist'], \
+                dinfo['clipthresh'], dinfo['clipniter'], \
+                dinfo['use_linefinder'], dinfo['thresh'], dinfo['edge'], dinfo['chan_avg_limit']]
+    
+    return ":".join(slblinfo)
+
+def parse_fitresult(sres):
+    """\
+    Parse the returned value of apply_bltable() or sub_baseline() and
+    extract row number, the best-fit coefficients and rms, then pack
+    them into a dictionary.
+    The input value is generated by Scantable::packFittingResults() and
+    formatted as 'row:coeff[0],coeff[1],..,coeff[n-1]:rms'. 
+    """
+    res = []
+    for i in xrange(len(sres)):
+        (srow, scoeff, srms) = sres[i].split(":")
+        row = int(srow)
+        rms = float(srms)
+        lscoeff = scoeff.split(",")
+        coeff = []
+        for j in xrange(len(lscoeff)):
+            coeff.append(float(lscoeff[j]))
+        res.append({'row': row, 'coeff': coeff, 'rms': rms})
+
+    return res
 
 class scantable(Scantable):
@@ -2556 +2683 @@
 
     @asaplog_post_dec
+    def apply_bltable(self, insitu=None, inbltable=None, outbltable=None, overwrite=None):
+        """\
+        Subtract baseline based on parameters written in Baseline Table.
+
+        Parameters:
+            insitu:        if False a new scantable is returned.
+                           Otherwise, the scaling is done in-situ
+                           The default is taken from .asaprc (False)
+            inbltable:     name of input baseline table. The row number of
+                           scantable and that of inbltable must be
+                           identical.
+            outbltable:    name of output baseline table where baseline 
+                           parameters and fitting results recorded.
+                           default is ''(no output).
+            overwrite:     if True, overwrites the existing baseline table
+                           specified in outbltable.
+                           default is False.
+        """
+
+        try:
+            varlist = vars()
+            if inbltable      is None: raise ValueError("bltable missing.")
+            if outbltable     is None: outbltable     = ''
+            if overwrite      is None: overwrite      = False
+
+            if insitu is None: insitu = rcParams['insitu']
+            if insitu:
+                workscan = self
+            else:
+                workscan = self.copy()
+
+            sres = workscan._apply_bltable(inbltable,
+                                           outbltable,
+                                           os.path.exists(outbltable),
+                                           overwrite)
+            res = parse_fitresult(sres)
+
+            workscan._add_history('apply_bltable', varlist)
+
+            if insitu:
+                self._assign(workscan)
+                return res
+            else:
+                return {'scantable': workscan, 'fitresults': res}
+        
+        except RuntimeError, e:
+            raise_fitting_failure_exception(e)
+
+    @asaplog_post_dec
+    def sub_baseline(self, insitu=None, blinfo=None, bltable=None, overwrite=None):
+        """\
+        Subtract baseline based on parameters written in the input list. 
+
+        Parameters:
+            insitu:        if False a new scantable is returned.
+                           Otherwise, the scaling is done in-situ
+                           The default is taken from .asaprc (False)
+            blinfo:        baseline parameter set stored in a dictionary
+                           or a list of dictionary. Each dictionary 
+                           corresponds to each spectrum and must contain
+                           the following keys and values:
+                             'row': row number, 
+                             'blfunc': function name. available ones include
+                                       'poly', 'chebyshev', 'cspline' and
+                                       'sinusoid', 
+                             'order': maximum order of polynomial. needed
+                                      if blfunc='poly' or 'chebyshev', 
+                             'npiece': number or piecewise polynomial.
+                                       needed if blfunc='cspline', 
+                             'nwave': a list of sinusoidal wave numbers.
+                                      needed if blfunc='sinusoid', and 
+                             'masklist': min-max windows for channel mask.
+                                         the specified ranges will be used
+                                         for fitting. 
+            bltable:       name of output baseline table where baseline
+                           parameters and fitting results recorded.
+                           default is ''(no output).
+            overwrite:     if True, overwrites the existing baseline table
+                           specified in bltable.
+                           default is False.
+                           
+        Example:
+            sub_baseline(blinfo=[{'row':0, 'blfunc':'poly', 'order':5,
+                                  'masklist':[[10,350],[352,510]]},
+                                 {'row':1, 'blfunc':'cspline', 'npiece':3,
+                                  'masklist':[[3,16],[19,404],[407,511]]}
+                                  ])
+
+                the first spectrum (row=0) will be fitted with polynomial
+                of order=5 and the next one (row=1) will be fitted with cubic
+                spline consisting of 3 pieces. 
+        """
+
+        try:
+            varlist = vars()
+            if blinfo         is None: blinfo         = []
+            if bltable        is None: bltable        = ''
+            if overwrite      is None: overwrite      = False
+
+            if insitu is None: insitu = rcParams['insitu']
+            if insitu:
+                workscan = self
+            else:
+                workscan = self.copy()
+
+            nrow = workscan.nrow()
+
+            in_blinfo = pack_blinfo(blinfo=blinfo, maxirow=nrow)
+
+            print "in_blinfo=< "+ str(in_blinfo)+" >"
+
+            sres = workscan._sub_baseline(in_blinfo,
+                                          bltable,
+                                          os.path.exists(bltable),
+                                          overwrite)
+            res = parse_fitresult(sres)
+            
+            workscan._add_history('sub_baseline', varlist)
+
+            if insitu:
+                self._assign(workscan)
+                return res
+            else:
+                return {'scantable': workscan, 'fitresults': res}
+
+        except RuntimeError, e:
+            raise_fitting_failure_exception(e)
+
+    @asaplog_post_dec
     def calc_aic(self, value=None, blfunc=None, order=None, mask=None,
                  whichrow=None, uselinefinder=None, edge=None,
@@ -2638 +2894 @@
                           clipniter=None, plot=None,
                           getresidual=None, showprogress=None, 
-                          minnrow=None, outlog=None, blfile=None, csvformat=None):
+                          minnrow=None, outlog=None,
+                          blfile=None, csvformat=None,
+                          bltable=None):
         """\
         Return a scan which has been baselined (all rows) with sinusoidal 
@@ -2697 +2955 @@
                            (default is '': no file/logger output)
             csvformat:     if True blfile is csv-formatted, default is False.
+            bltable:       name of a baseline table where fitting results
+                           (coefficients, rms, etc.) are to be written.
+                           if given, fitting results will NOT be output to
+                           scantable (insitu=True) or None will be 
+                           returned (insitu=False). 
+                           (default is "": no table output)
 
         Example:
@@ -2734 +2998 @@
             if blfile        is None: blfile        = ''
             if csvformat     is None: csvformat     = False
-
-            if csvformat:
-                scsvformat = "T"
-            else:
-                scsvformat = "F"
+            if bltable       is None: bltable       = ''
+
+            sapplyfft = 'true' if applyfft else 'false'
+            fftinfo = ','.join([sapplyfft, fftmethod.lower(), str(fftthresh).lower()])
+
+            scsvformat = 'T' if csvformat else 'F'
 
             #CURRENTLY, PLOT=true is UNAVAILABLE UNTIL sinusoidal fitting is implemented as a fitter method. 
-            workscan._sinusoid_baseline(mask, applyfft, fftmethod.lower(), 
-                                        str(fftthresh).lower(), 
+            workscan._sinusoid_baseline(mask,
+                                        fftinfo, 
+                                        #applyfft, fftmethod.lower(), 
+                                        #str(fftthresh).lower(), 
                                         workscan._parse_wn(addwn), 
                                         workscan._parse_wn(rejwn),
@@ -2749 +3016 @@
                                         pack_progress_params(showprogress, 
                                                              minnrow),
-                                        outlog, scsvformat+blfile)
+                                        outlog, scsvformat+blfile,
+                                        bltable)
             workscan._add_history('sinusoid_baseline', varlist)
-            
-            if insitu:
-                self._assign(workscan)
+
+            if bltable == '':
+                if insitu:
+                    self._assign(workscan)
+                else:
+                    return workscan
             else:
-                return workscan
+                if not insitu:
+                    return None
             
         except RuntimeError, e:
@@ -2768 +3040 @@
                                chan_avg_limit=None, plot=None,
                                getresidual=None, showprogress=None, 
-                               minnrow=None, outlog=None, blfile=None, csvformat=None):
+                               minnrow=None, outlog=None,
+                               blfile=None, csvformat=None,
+                               bltable=None):
         """\
         Return a scan which has been baselined (all rows) with sinusoidal 
@@ -2849 +3123 @@
                             (default is "": no file/logger output)
             csvformat:      if True blfile is csv-formatted, default is False.
+            bltable:        name of a baseline table where fitting results
+                            (coefficients, rms, etc.) are to be written.
+                            if given, fitting results will NOT be output to
+                            scantable (insitu=True) or None will be 
+                            returned (insitu=False). 
+                            (default is "": no table output)
 
         Example:
@@ -2886 +3166 @@
             if blfile         is None: blfile         = ''
             if csvformat      is None: csvformat      = False
-
-            if csvformat:
-                scsvformat = "T"
-            else:
-                scsvformat = "F"
+            if bltable        is None: bltable        = ''
+
+            sapplyfft = 'true' if applyfft else 'false'
+            fftinfo = ','.join([sapplyfft, fftmethod.lower(), str(fftthresh).lower()])
+
+            scsvformat = 'T' if csvformat else 'F'
 
             #CURRENTLY, PLOT=true is UNAVAILABLE UNTIL sinusoidal fitting is implemented as a fitter method. 
-            workscan._auto_sinusoid_baseline(mask, applyfft, 
-                                             fftmethod.lower(), 
-                                             str(fftthresh).lower(), 
+            workscan._auto_sinusoid_baseline(mask,
+                                             fftinfo, 
                                              workscan._parse_wn(addwn), 
                                              workscan._parse_wn(rejwn), 
@@ -2904 +3184 @@
                                              pack_progress_params(showprogress,
                                                                   minnrow), 
-                                             outlog, scsvformat+blfile)
+                                             outlog, scsvformat+blfile, bltable)
             workscan._add_history("auto_sinusoid_baseline", varlist)
-            
-            if insitu:
-                self._assign(workscan)
+
+            if bltable == '':
+                if insitu:
+                    self._assign(workscan)
+                else:
+                    return workscan
             else:
-                return workscan
+                if not insitu:
+                    return None
             
         except RuntimeError, e:
@@ -2919 +3203 @@
                          clipthresh=None, clipniter=None, plot=None, 
                          getresidual=None, showprogress=None, minnrow=None, 
-                         outlog=None, blfile=None, csvformat=None):
+                         outlog=None, blfile=None, csvformat=None,
+                         bltable=None):
         """\
         Return a scan which has been baselined (all rows) by cubic spline 
@@ -2949 +3234 @@
                           (default is "": no file/logger output)
             csvformat:    if True blfile is csv-formatted, default is False.
+            bltable:      name of a baseline table where fitting results
+                          (coefficients, rms, etc.) are to be written.
+                          if given, fitting results will NOT be output to
+                          scantable (insitu=True) or None will be 
+                          returned (insitu=False). 
+                          (default is "": no table output)
 
         Example:
@@ -2981 +3272 @@
             if outlog       is None: outlog       = False
             if blfile       is None: blfile       = ''
-            if csvformat     is None: csvformat     = False
-
-            if csvformat:
-                scsvformat = "T"
-            else:
-                scsvformat = "F"
+            if csvformat    is None: csvformat    = False
+            if bltable      is None: bltable      = ''
+
+            scsvformat = 'T' if csvformat else 'F'
 
             #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method. 
-            workscan._cspline_baseline(mask, npiece, clipthresh, clipniter, 
+            workscan._cspline_baseline(mask, npiece,
+                                       clipthresh, clipniter, 
                                        getresidual, 
                                        pack_progress_params(showprogress, 
                                                             minnrow),
-                                       outlog, scsvformat+blfile)
+                                       outlog, scsvformat+blfile,
+                                       bltable)
             workscan._add_history("cspline_baseline", varlist)
-            
-            if insitu:
-                self._assign(workscan)
+
+            if bltable == '':
+                if insitu:
+                    self._assign(workscan)
+                else:
+                    return workscan
             else:
-                return workscan
+                if not insitu:
+                    return None
             
         except RuntimeError, e:
@@ -3010 +3305 @@
                               getresidual=None, plot=None,
                               showprogress=None, minnrow=None, outlog=None,
-                              blfile=None, csvformat=None):
+                              blfile=None, csvformat=None, bltable=None):
         """\
         Return a scan which has been baselined (all rows) by cubic spline
@@ -3062 +3357 @@
                             (default is "": no file/logger output)
             csvformat:      if True blfile is csv-formatted, default is False.
+            bltable:        name of a baseline table where fitting results
+                            (coefficients, rms, etc.) are to be written.
+                            if given, fitting results will NOT be output to
+                            scantable (insitu=True) or None will be 
+                            returned (insitu=False). 
+                            (default is "": no table output)
 
         Example:
@@ -3095 +3396 @@
             if blfile         is None: blfile         = ''
             if csvformat      is None: csvformat      = False
-
-            if csvformat:
-                scsvformat = "T"
-            else:
-                scsvformat = "F"
+            if bltable        is None: bltable        = ''
+
+            scsvformat = 'T' if csvformat else 'F'
 
             #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method.
-            workscan._auto_cspline_baseline(mask, npiece, clipthresh, 
-                                            clipniter, 
+            workscan._auto_cspline_baseline(mask, npiece,
+                                            clipthresh, clipniter, 
                                             normalise_edge_param(edge), 
                                             threshold, 
@@ -3109 +3408 @@
                                             pack_progress_params(showprogress, 
                                                                  minnrow), 
-                                            outlog, scsvformat+blfile)
+                                            outlog,
+                                            scsvformat+blfile,
+                                            bltable)
             workscan._add_history("auto_cspline_baseline", varlist)
-            
-            if insitu:
-                self._assign(workscan)
+
+            if bltable == '':
+                if insitu:
+                    self._assign(workscan)
+                else:
+                    return workscan
             else:
-                return workscan
+                if not insitu:
+                    return None
             
         except RuntimeError, e:
@@ -3124 +3429 @@
                            clipthresh=None, clipniter=None, plot=None, 
                            getresidual=None, showprogress=None, minnrow=None, 
-                           outlog=None, blfile=None, csvformat=None):
+                           outlog=None, blfile=None, csvformat=None,
+                           bltable=None):
         """\
         Return a scan which has been baselined (all rows) by Chebyshev polynomials.
@@ -3153 +3459 @@
                           (default is "": no file/logger output)
             csvformat:    if True blfile is csv-formatted, default is False.
+            bltable:      name of a baseline table where fitting results
+                          (coefficients, rms, etc.) are to be written.
+                          if given, fitting results will NOT be output to
+                          scantable (insitu=True) or None will be 
+                          returned (insitu=False). 
+                          (default is "": no table output)
 
         Example:
@@ -3174 +3486 @@
                 workscan = self.copy()
 
-            #if mask         is None: mask         = [True for i in xrange(workscan.nchan())]
             if mask         is None: mask         = []
             if order        is None: order        = 5
@@ -3185 +3496 @@
             if outlog       is None: outlog       = False
             if blfile       is None: blfile       = ''
-            if csvformat     is None: csvformat     = False
-
-            if csvformat:
-                scsvformat = "T"
-            else:
-                scsvformat = "F"
+            if csvformat    is None: csvformat    = False
+            if bltable      is None: bltable      = ''
+
+            scsvformat = 'T' if csvformat else 'F'
 
             #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method. 
-            workscan._chebyshev_baseline(mask, order, clipthresh, clipniter, 
+            workscan._chebyshev_baseline(mask, order,
+                                         clipthresh, clipniter, 
                                          getresidual, 
                                          pack_progress_params(showprogress, 
                                                               minnrow),
-                                         outlog, scsvformat+blfile)
+                                         outlog, scsvformat+blfile, 
+                                         bltable)
             workscan._add_history("chebyshev_baseline", varlist)
-            
-            if insitu:
-                self._assign(workscan)
+
+            if bltable == '':
+                if insitu:
+                    self._assign(workscan)
+                else:
+                    return workscan
             else:
-                return workscan
+                if not insitu:
+                    return None
             
         except RuntimeError, e:
@@ -3214 +3529 @@
                               getresidual=None, plot=None,
                               showprogress=None, minnrow=None, outlog=None,
-                              blfile=None, csvformat=None):
+                              blfile=None, csvformat=None, bltable=None):
         """\
         Return a scan which has been baselined (all rows) by Chebyshev polynomials. 
@@ -3265 +3580 @@
                             (default is "": no file/logger output)
             csvformat:      if True blfile is csv-formatted, default is False.
+            bltable:        name of a baseline table where fitting results
+                            (coefficients, rms, etc.) are to be written.
+                            if given, fitting results will NOT be output to
+                            scantable (insitu=True) or None will be 
+                            returned (insitu=False). 
+                            (default is "": no table output)
 
         Example:
@@ -3283 +3604 @@
                 workscan = self.copy()
             
-            #if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
             if mask           is None: mask           = []
             if order          is None: order          = 5
@@ -3298 +3618 @@
             if blfile         is None: blfile         = ''
             if csvformat      is None: csvformat      = False
-
-            if csvformat:
-                scsvformat = "T"
-            else:
-                scsvformat = "F"
+            if bltable        is None: bltable        = ''
+
+            scsvformat = 'T' if csvformat else 'F'
 
             #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method.
-            workscan._auto_chebyshev_baseline(mask, order, clipthresh, 
-                                              clipniter, 
+            workscan._auto_chebyshev_baseline(mask, order,
+                                              clipthresh, clipniter, 
                                               normalise_edge_param(edge), 
                                               threshold, 
@@ -3312 +3630 @@
                                               pack_progress_params(showprogress, 
                                                                    minnrow), 
-                                              outlog, scsvformat+blfile)
+                                              outlog, scsvformat+blfile,
+                                              bltable)
             workscan._add_history("auto_chebyshev_baseline", varlist)
-            
-            if insitu:
-                self._assign(workscan)
+
+            if bltable == '':
+                if insitu:
+                    self._assign(workscan)
+                else:
+                    return workscan
             else:
-                return workscan
+                if not insitu:
+                    return None
             
         except RuntimeError, e:
@@ -3324 +3647 @@
 
     @asaplog_post_dec
-    def poly_baseline(self, mask=None, order=None, insitu=None, plot=None, 
+    def poly_baseline(self, insitu=None, mask=None, order=None,
+                      clipthresh=None, clipniter=None, plot=None, 
                       getresidual=None, showprogress=None, minnrow=None, 
-                      outlog=None, blfile=None, csvformat=None):
+                      outlog=None, blfile=None, csvformat=None,
+                      bltable=None):
         """\
         Return a scan which has been baselined (all rows) by a polynomial.
@@ -3335 +3660 @@
             mask:         an optional mask
             order:        the order of the polynomial (default is 0)
+            clipthresh:   Clipping threshold. (default is 3.0, unit: sigma)
+            clipniter:    maximum number of iteration of 'clipthresh'-sigma 
+                          clipping (default is 0)
             plot:         plot the fit and the residual. In this each
                           indivual fit has to be approved, by typing 'y'
@@ -3350 +3678 @@
                           (default is "": no file/logger output)
             csvformat:    if True blfile is csv-formatted, default is False.
+            bltable:      name of a baseline table where fitting results
+                          (coefficients, rms, etc.) are to be written.
+                          if given, fitting results will NOT be output to
+                          scantable (insitu=True) or None will be 
+                          returned (insitu=False). 
+                          (default is "": no table output)
 
         Example:
@@ -3367 +3701 @@
                 workscan = self.copy()
 
-            #if mask         is None: mask         = [True for i in \
-            #                                           xrange(workscan.nchan())]
             if mask         is None: mask         = []
             if order        is None: order        = 0
+            if clipthresh   is None: clipthresh   = 3.0
+            if clipniter    is None: clipniter    = 0
             if plot         is None: plot         = False
             if getresidual  is None: getresidual  = True
@@ -3376 +3710 @@
             if minnrow      is None: minnrow      = 1000
             if outlog       is None: outlog       = False
-            if blfile       is None: blfile       = ""
+            if blfile       is None: blfile       = ''
             if csvformat    is None: csvformat    = False
-
-            if csvformat:
-                scsvformat = "T"
-            else:
-                scsvformat = "F"
+            if bltable      is None: bltable      = ''
+
+            scsvformat = 'T' if csvformat else 'F'
 
             if plot:
@@ -3446 +3778 @@
                     blf.close()
             else:
-                workscan._poly_baseline(mask, order, getresidual, 
+                workscan._poly_baseline(mask, order,
+                                        clipthresh, clipniter, #
+                                        getresidual, 
                                         pack_progress_params(showprogress, 
                                                              minnrow), 
-                                        outlog, scsvformat+blfile)
+                                        outlog, scsvformat+blfile,
+                                        bltable)  #
             
             workscan._add_history("poly_baseline", varlist)
@@ -3462 +3797 @@
 
     @asaplog_post_dec
-    def auto_poly_baseline(self, mask=None, order=None, edge=None, 
-                           threshold=None, chan_avg_limit=None,
-                           plot=None, insitu=None,
-                           getresidual=None, showprogress=None, 
-                           minnrow=None, outlog=None, blfile=None, csvformat=None):
+    def auto_poly_baseline(self, insitu=None, mask=None, order=None,
+                           clipthresh=None, clipniter=None, 
+                           edge=None, threshold=None, chan_avg_limit=None,
+                           getresidual=None, plot=None, 
+                           showprogress=None, minnrow=None, outlog=None,
+                           blfile=None, csvformat=None, bltable=None):
         """\
         Return a scan which has been baselined (all rows) by a polynomial.
@@ -3478 +3814 @@
             mask:           an optional mask retreived from scantable
             order:          the order of the polynomial (default is 0)
+            clipthresh:     Clipping threshold. (default is 3.0, unit: sigma)
+            clipniter:      maximum number of iteration of 'clipthresh'-sigma 
+                            clipping (default is 0)
             edge:           an optional number of channel to drop at
                             the edge of spectrum. If only one value is
@@ -3513 +3852 @@
                             (default is "": no file/logger output)
             csvformat:      if True blfile is csv-formatted, default is False.
+            bltable:        name of a baseline table where fitting results
+                            (coefficients, rms, etc.) are to be written.
+                            if given, fitting results will NOT be output to
+                            scantable (insitu=True) or None will be 
+                            returned (insitu=False). 
+                            (default is "": no table output)
 
         Example:
@@ -3528 +3873 @@
                 workscan = self.copy()
 
-            #if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
             if mask           is None: mask           = []
             if order          is None: order          = 0
+            if clipthresh     is None: clipthresh     = 3.0
+            if clipniter      is None: clipniter      = 0
             if edge           is None: edge           = (0, 0)
             if threshold      is None: threshold      = 3
@@ -3541 +3887 @@
             if blfile         is None: blfile         = ''
             if csvformat      is None: csvformat      = False
-
-            if csvformat:
-                scsvformat = "T"
-            else:
-                scsvformat = "F"
+            if bltable        is None: bltable        = ''
+
+            scsvformat = 'T' if csvformat else 'F'
 
             edge = normalise_edge_param(edge)
@@ -3615 +3959 @@
                 if outblfile: blf.close()
             else:
-                workscan._auto_poly_baseline(mask, order, edge, threshold, 
+                workscan._auto_poly_baseline(mask, order,
+                                             clipthresh, clipniter, 
+                                             edge, threshold, 
                                              chan_avg_limit, getresidual, 
                                              pack_progress_params(showprogress,
                                                                   minnrow), 
-                                             outlog, scsvformat+blfile)
-
+                                             outlog, scsvformat+blfile,
+                                             bltable)
             workscan._add_history("auto_poly_baseline", varlist)
-            
-            if insitu:
-                self._assign(workscan)
+
+            if bltable == '':
+                if insitu:
+                    self._assign(workscan)
+                else:
+                    return workscan
             else:
-                return workscan
+                if not insitu:
+                    return None
             
         except RuntimeError, e:

trunk/src/STBaselineEnum.h

@@ -28 +28 @@
 class STBaselineFunc  {
 public:
-  enum FuncName {Polynomial = 0,
+  enum FuncName {Polynomial = 1,
                  CSpline,
                  Sinusoid,

trunk/src/STBaselineTable.cpp

@@ -51 +51 @@
 void STBaselineTable::setup()
 {
-  table_.addColumn(ScalarColumnDesc<uInt>("NCHAN"));
+  table_.addColumn(ScalarColumnDesc<Bool>("APPLY"));
   table_.addColumn(ScalarColumnDesc<uInt>("FUNC_TYPE"));
-  table_.addColumn(ArrayColumnDesc<uInt>("FUNC_PARAM"));
+  table_.addColumn(ArrayColumnDesc<Int>("FUNC_PARAM"));
   table_.addColumn(ArrayColumnDesc<Float>("FUNC_FPARAM"));
-  table_.addColumn(ScalarColumnDesc<uInt>("CLIP_ITERATION"));
-  table_.addColumn(ScalarColumnDesc<Float>("CLIP_THRESHOLD"));
   table_.addColumn(ArrayColumnDesc<uInt>("MASKLIST"));
   table_.addColumn(ArrayColumnDesc<Float>("RESULT"));
   table_.addColumn(ScalarColumnDesc<Float>("RMS"));
+  table_.addColumn(ScalarColumnDesc<uInt>("NCHAN"));
+  table_.addColumn(ScalarColumnDesc<Float>("CLIP_THRESHOLD"));
+  table_.addColumn(ScalarColumnDesc<uInt>("CLIP_ITERATION"));
+  table_.addColumn(ScalarColumnDesc<Float>("LF_THRESHOLD"));
+  table_.addColumn(ScalarColumnDesc<uInt>("LF_AVERAGE"));
+  table_.addColumn(ArrayColumnDesc<uInt>("LF_EDGE"));
 
   table_.rwKeywordSet().define("ApplyType", "BASELINE");
@@ -68 +72 @@
 void STBaselineTable::attachOptionalColumns()
 {
-  nchanCol_.attach(table_, "NCHAN");
+  applyCol_.attach(table_, "APPLY");
   ftypeCol_.attach(table_, "FUNC_TYPE");
   fparCol_.attach(table_, "FUNC_PARAM");
   ffparCol_.attach(table_, "FUNC_FPARAM");
-  citerCol_.attach(table_, "CLIP_ITERATION");
-  cthresCol_.attach(table_, "CLIP_THRESHOLD");
   maskCol_.attach(table_, "MASKLIST");
   resCol_.attach(table_, "RESULT");
   rmsCol_.attach(table_, "RMS");
+  nchanCol_.attach(table_, "NCHAN");
+  cthresCol_.attach(table_, "CLIP_THRESHOLD");
+  citerCol_.attach(table_, "CLIP_ITERATION");
+  lfthresCol_.attach(table_, "LF_THRESHOLD");
+  lfavgCol_.attach(table_, "LF_AVERAGE");
+  lfedgeCol_.attach(table_, "LF_EDGE");
 }
 
@@ -90 +98 @@
                               uInt beamno, uInt ifno, uInt polno, 
                               uInt freqid, Double time, 
-                              uInt nchan, 
+                              Bool apply, 
                               STBaselineFunc::FuncName ftype, 
-                              Vector<uInt> fpar, 
+                              Vector<Int> fpar, 
                               Vector<Float> ffpar, 
-                              uInt citer, 
-                              Float cthres,
                               Vector<uInt> mask,
                               Vector<Float> res,
-                              Float rms)
+                              Float rms, 
+                              uInt nchan, 
+                              Float cthres,
+                              uInt citer, 
+                              Float lfthres, 
+                              uInt lfavg, 
+                              Vector<uInt> lfedge)
 {
   if (irow >= (uInt)nrow()) {
@@ -110 +122 @@
 
   setbasedata(irow, scanno, cycleno, beamno, ifno, polno, freqid, time);
-  nchanCol_.put(irow, nchan);
+  applyCol_.put(irow, apply);
   ftypeCol_.put(irow, uInt(ftype));
   fparCol_.put(irow, fpar);
   ffparCol_.put(irow, ffpar);
-  citerCol_.put(irow, citer);
-  cthresCol_.put(irow, cthres);
   maskCol_.put(irow, mask);
   resCol_.put(irow, res);
   rmsCol_.put(irow, rms);
+  nchanCol_.put(irow, nchan);
+  cthresCol_.put(irow, cthres);
+  citerCol_.put(irow, citer);
+  lfthresCol_.put(irow, lfthres);
+  lfavgCol_.put(irow, lfavg);
+  lfedgeCol_.put(irow, lfedge);
 }
 
@@ -124 +140 @@
                                  uInt beamno, uInt ifno, uInt polno, 
                                  uInt freqid, Double time, 
-                                 uInt nchan, 
+                                 Bool apply, 
                                  STBaselineFunc::FuncName ftype, 
-                                 Vector<uInt> fpar, 
+                                 Vector<Int> fpar, 
                                  Vector<Float> ffpar, 
-                                 uInt citer, 
-                                 Float cthres,
                                  Vector<uInt> mask,
                                  Vector<Float> res,
-                                 Float rms)
+                                 Float rms,
+                                 uInt nchan, 
+                                 Float cthres,
+                                 uInt citer, 
+                                 Float lfthres, 
+                                 uInt lfavg, 
+                                 Vector<uInt> lfedge)
 {
   uInt irow = nrow();
   table_.addRow(1, True);
   setdata(irow, scanno, cycleno, beamno, ifno, polno, freqid, time, 
-          nchan, ftype, fpar, ffpar, citer, cthres, mask, res, rms);
-}
-
-Vector<STBaselineFunc::FuncName> STBaselineTable::getFunctionAsString()
+          apply, ftype, fpar, ffpar, mask, res, rms, 
+          nchan, cthres, citer, lfthres, lfavg, lfedge);
+}
+
+void STBaselineTable::appendbasedata(int scanno, int cycleno, 
+                                     int beamno, int ifno, int polno, 
+                                     int freqid, Double time)
+{
+  uInt irow = nrow();
+  table_.addRow(1, True);
+  setbasedata(irow, uInt(scanno), uInt(cycleno), uInt(beamno), uInt(ifno), uInt(polno), uInt(freqid), time);
+}
+
+void STBaselineTable::setresult(casa::uInt irow, 
+                                casa::Vector<casa::Float> res, 
+                                casa::Float rms)
+{
+  resCol_.put(irow, res);
+  rmsCol_.put(irow, rms);
+}
+
+bool STBaselineTable::getApply(int irow)
+{
+  return (bool)applyCol_.get(irow);
+}
+
+void STBaselineTable::setApply(int irow, bool apply)
+{
+  applyCol_.put(uInt(irow), Bool(apply));
+}
+
+Vector<STBaselineFunc::FuncName> STBaselineTable::getFunctionNames()
 {
   Vector<uInt> rawBlfuncColumn = ftypeCol_.getColumn();
@@ -149 +197 @@
   }
   return blfuncColumn;
+}
+
+STBaselineFunc::FuncName STBaselineTable::getFunctionName(int irow)
+{
+  return STBaselineFunc::FuncName(ftypeCol_.get(irow));
+}
+
+std::vector<int> STBaselineTable::getFuncParam(int irow)
+{
+  Vector<Int> uiparam = fparCol_.get(irow);
+  std::vector<int> res(uiparam.size());
+  for (uInt i = 0; i < res.size(); ++i) {
+    res[i] = (int)uiparam[i];
+  }
+  return res;
+}
+
+std::vector<bool> STBaselineTable::getMask(int irow)
+{
+  uInt nchan = getNChan(irow);
+  Vector<uInt> masklist = maskCol_.get(irow);
+  std::vector<int> masklist1(masklist.size());
+  for (uInt i = 0; i < masklist1.size(); ++i) {
+    masklist1[i] = (int)masklist[i];
+  }
+  return Scantable::getMaskFromMaskList(nchan, masklist1);
+}
+
+uInt STBaselineTable::getNChan(int irow)
+{
+  return nchanCol_.get(irow);
 }
 

trunk/src/STBaselineTable.h

@@ -46 +46 @@
                casa::uInt beamno, casa::uInt ifno, casa::uInt polno, 
                casa::uInt freqid, casa::Double time, 
-               casa::uInt nchan, 
+               casa::Bool apply,
                STBaselineFunc::FuncName ftype, 
-               casa::Vector<casa::uInt> fpar, 
+               casa::Vector<casa::Int> fpar, 
                casa::Vector<casa::Float> ffpar, 
-               casa::uInt citer, 
-               casa::Float cthres,
                casa::Vector<casa::uInt> mask,
                casa::Vector<casa::Float> res,
-               casa::Float rms);
+               casa::Float rms, 
+               casa::uInt nchan, 
+               casa::Float cthres,
+               casa::uInt citer, 
+               casa::Float lfthres, 
+               casa::uInt lfavg, 
+               casa::Vector<casa::uInt> lfedge);
   void appenddata(casa::uInt scanno, casa::uInt cycleno, 
                   casa::uInt beamno, casa::uInt ifno, casa::uInt polno, 
                   casa::uInt freqid, casa::Double time, 
-                  casa::uInt nchan, 
+                  casa::Bool apply,
                   STBaselineFunc::FuncName ftype, 
-                  casa::Vector<casa::uInt> fpar, 
+                  casa::Vector<casa::Int> fpar, 
                   casa::Vector<casa::Float> ffpar, 
-                  casa::uInt citer, 
-                  casa::Float cthres,
                   casa::Vector<casa::uInt> mask,
                   casa::Vector<casa::Float> res,
-                  casa::Float rms);
+                  casa::Float rms, 
+                  casa::uInt nchan, 
+                  casa::Float cthres,
+                  casa::uInt citer, 
+                  casa::Float lfthres, 
+                  casa::uInt lfavg, 
+                  casa::Vector<casa::uInt> lfedge);
+  void appendbasedata(int scanno, int cycleno, 
+                      int beamno, int ifno, int polno, 
+                      int freqid, casa::Double time);
+  void setresult(casa::uInt irow, 
+                 casa::Vector<casa::Float> res, 
+                 casa::Float rms);
   casa::uInt nchan(casa::uInt ifno);
+  casa::Vector<casa::Bool> getApply() {return applyCol_.getColumn();}
+  bool getApply(int irow);
   casa::Vector<casa::uInt> getFunction() {return ftypeCol_.getColumn();}
-  casa::Vector<STBaselineFunc::FuncName> getFunctionAsString();
-  casa::Matrix<casa::uInt> getFuncParam() {return fparCol_.getColumn();}
+  casa::Vector<STBaselineFunc::FuncName> getFunctionNames();
+  STBaselineFunc::FuncName getFunctionName(int irow);
+  casa::Matrix<casa::Int> getFuncParam() {return fparCol_.getColumn();}
+  std::vector<int> getFuncParam(int irow);
   casa::Matrix<casa::Float> getFuncFParam() {return ffparCol_.getColumn();}
-  casa::Vector<casa::uInt> getClipIteration() {return citerCol_.getColumn();}
-  casa::Vector<casa::Float> getClipThreshold() {return cthresCol_.getColumn();}
   casa::Matrix<casa::uInt> getMaskList() {return maskCol_.getColumn();}
+  std::vector<bool> getMask(int irow);
   casa::Matrix<casa::Float> getResult() {return resCol_.getColumn();}
   casa::Vector<casa::Float> getRms() {return rmsCol_.getColumn();}
+  casa::Vector<casa::uInt> getNChan() {return nchanCol_.getColumn();}
+  casa::uInt getNChan(int irow);
+  casa::Vector<casa::Float> getClipThreshold() {return cthresCol_.getColumn();}
+  casa::Vector<casa::uInt> getClipIteration() {return citerCol_.getColumn();}
+  casa::Vector<casa::Float> getLineFinderThreshold() {return lfthresCol_.getColumn();}
+  casa::Vector<casa::uInt> getLineFinderChanAvg() {return lfavgCol_.getColumn();}
+  casa::Matrix<casa::uInt> getLineFinderEdge() {return lfedgeCol_.getColumn();}
+  void setApply(int irow, bool apply);
 
 private:
   static const casa::String name_ ;
-  casa::ScalarColumn<casa::uInt> nchanCol_;
+  casa::ScalarColumn<casa::Bool> applyCol_;
   casa::ScalarColumn<casa::uInt> ftypeCol_;
-  casa::ArrayColumn<casa::uInt> fparCol_;
+  casa::ArrayColumn<casa::Int> fparCol_;
   casa::ArrayColumn<casa::Float> ffparCol_;
-  casa::ScalarColumn<casa::uInt> citerCol_;
-  casa::ScalarColumn<casa::Float> cthresCol_;
   casa::ArrayColumn<casa::uInt> maskCol_;
   casa::ArrayColumn<casa::Float> resCol_;
   casa::ScalarColumn<casa::Float> rmsCol_;
+  casa::ScalarColumn<casa::uInt> nchanCol_;
+  casa::ScalarColumn<casa::Float> cthresCol_;
+  casa::ScalarColumn<casa::uInt> citerCol_;
+  casa::ScalarColumn<casa::Float> lfthresCol_;
+  casa::ScalarColumn<casa::uInt> lfavgCol_;
+  casa::ArrayColumn<casa::uInt> lfedgeCol_;
 };
 

trunk/src/Scantable.cpp

@@ -2490 +2490 @@
 }
 
-void Scantable::polyBaseline(const std::vector<bool>& mask, int order, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile)
-{
+std::vector<std::string> Scantable::applyBaselineTable(const std::string& bltable, const std::string& outbltable, const bool outbltableexists, const bool overwrite)
+{
+  STBaselineTable* btin = new STBaselineTable(bltable);
+
+  Vector<Bool> applyCol = btin->getApply();
+  int nRowBl = applyCol.size();
+  if (nRowBl != nrow()) {
+    throw(AipsError("Scantable and bltable have different number of rows."));
+  }
+
+  std::vector<std::string> res;
+  res.clear();
+
+  bool outBaselineTable = ((outbltable != "") && (!outbltableexists || overwrite));
+  bool bltableidentical = (bltable == outbltable);
+  STBaselineTable* btout = new STBaselineTable(*this);
+  ROScalarColumn<Double> *tcol = new ROScalarColumn<Double>(table_, "TIME");
+  Vector<Double> timeSecCol = tcol->getColumn();
+
+  for (int whichrow = 0; whichrow < nRowBl; ++whichrow) {
+    if (applyCol[whichrow]) {
+      std::vector<float> spec = getSpectrum(whichrow);
+
+      //--channel mask--  maybe the following choices should be available
+      std::vector<bool> mask = btin->getMask(whichrow);  //use mask_bltable only (default)
+      //std::vector<bool> mask = getMask(whichrow);    // or mask_scantable only
+      //std::vector<bool> mask = getCompositeChanMask(whichrow, btin->getMask(whichrow)); // or mask_scantable && mask_bltable
+
+      STBaselineFunc::FuncName ftype = btin->getFunctionName(whichrow);
+      std::vector<int> fpar = btin->getFuncParam(whichrow);
+      std::vector<float> params;
+      float rms;
+      std::vector<float> resfit = doApplyBaselineTable(spec, mask, ftype, fpar, params, rms);
+
+      setSpectrum(resfit, whichrow);
+
+      res.push_back(packFittingResults(whichrow, params, rms));
+
+      if (outBaselineTable) {
+        Vector<Int> fparam(fpar.size());
+        for (uInt j = 0; j < fparam.size(); ++j) {
+          fparam[j] = (Int)fpar[j];
+        }
+        std::vector<int> maskList0;
+        maskList0.clear();
+        for (uInt j = 0; j < mask.size(); ++j) {
+          if (mask[j]) {
+            if ((j == 0)||(j == mask.size()-1)) {
+              maskList0.push_back(j);
+            } else {
+              if ((mask[j])&&(!mask[j-1])) {
+                maskList0.push_back(j);
+              }
+              if ((mask[j])&&(!mask[j+1])) {
+                maskList0.push_back(j);
+              }
+            }
+          }
+        }
+        Vector<uInt> maskList(maskList0.size());
+        for (uInt j = 0; j < maskList0.size(); ++j) {
+          maskList[j] = (uInt)maskList0[j];
+        }
+
+        if (outbltableexists) {
+          if (overwrite) {
+            if (bltableidentical) {
+              btin->setresult(uInt(whichrow), Vector<Float>(params), Float(rms));
+            } else {
+              btout->setresult(uInt(whichrow), Vector<Float>(params), Float(rms));
+            }
+          }
+        } else {
+          btout->appenddata(uInt(getScan(whichrow)), uInt(getCycle(whichrow)), 
+                            uInt(getBeam(whichrow)), uInt(getIF(whichrow)), uInt(getPol(whichrow)), 
+                            uInt(0), timeSecCol[whichrow], Bool(true), ftype, fparam, 
+                            Vector<Float>(), maskList, Vector<Float>(params), 
+                            Float(rms), uInt(spec.size()), Float(3.0), uInt(0), 
+                            Float(0.0), uInt(0), Vector<uInt>());
+        }
+      }
+    }
+  }
+
+  if (outBaselineTable) {
+    if (bltableidentical) {
+      btin->save(outbltable);
+    } else {
+      btout->save(outbltable);
+    }
+  }
+  delete btin;
+  delete btout;
+
+  return res;
+}
+
+std::vector<std::string> Scantable::subBaseline(const std::vector<std::string>& blInfoList, const std::string& outbltable, const bool outbltableexists, const bool overwrite)
+{
+  int nRowBl = blInfoList.size();
+  int nRowSt = nrow();
+
+  std::vector<std::string> res;
+  res.clear();
+
+  bool outBaselineTable = ((outbltable != "") && (!outbltableexists || overwrite));
+  if ((outbltable != "") && outbltableexists && !overwrite) {
+    throw(AipsError("Cannot overwrite bltable. Set overwrite=True."));
+  }
+
+  STBaselineTable* bt = new STBaselineTable(*this);
+  ROScalarColumn<Double> *tcol = new ROScalarColumn<Double>(table_, "TIME");
+  Vector<Double> timeSecCol = tcol->getColumn();
+
+  if (outBaselineTable && !outbltableexists) {
+    for (int i = 0; i < nRowSt; ++i) {
+      bt->appendbasedata(getScan(i), getCycle(i), getBeam(i), getIF(i), getPol(i), 
+                         0, timeSecCol[i]);
+      bt->setApply(i, false);
+    }
+  }
+
+  for (int i = 0; i < nRowBl; ++i) {
+    int irow;
+    STBaselineFunc::FuncName ftype;
+    std::vector<bool> mask;
+    std::vector<int> fpar;
+    float clipth;
+    int clipn;
+    bool uself;
+    float lfth;
+    std::vector<int> lfedge;
+    int lfavg;
+    parseBlInfo(blInfoList[i], irow, ftype, fpar, mask, clipth, clipn, uself, lfth, lfedge, lfavg);
+
+    if (irow < nRowSt) {
+      std::vector<float> spec = getSpectrum(irow);
+      std::vector<float> params;
+      float rms;
+      std::vector<bool> finalmask;
+
+      std::vector<float> resfit = doSubtractBaseline(spec, mask, ftype, fpar, params, rms, finalmask, clipth, clipn, uself, irow, lfth, lfedge, lfavg);
+      setSpectrum(resfit, irow);
+      res.push_back(packFittingResults(irow, params, rms));
+
+      if (outBaselineTable) {
+        Vector<Int> fparam(fpar.size());
+        for (uInt j = 0; j < fparam.size(); ++j) {
+          fparam[j] = (Int)fpar[j];
+        }
+        std::vector<int> maskList0;
+        maskList0.clear();
+        for (uInt j = 0; j < finalmask.size(); ++j) {
+          if (finalmask[j]) {
+            if ((j == 0)||(j == finalmask.size()-1)) {
+              maskList0.push_back(j);
+            } else {
+              if ((finalmask[j])&&(!finalmask[j-1])) {
+                maskList0.push_back(j);
+              }
+              if ((finalmask[j])&&(!finalmask[j+1])) {
+                maskList0.push_back(j);
+              }
+            }
+          }
+        }
+        Vector<uInt> maskList(maskList0.size());
+        for (uInt j = 0; j < maskList0.size(); ++j) {
+          maskList[j] = (uInt)maskList0[j];
+        }
+
+        bt->setdata(uInt(irow), 
+                    uInt(getScan(irow)), uInt(getCycle(irow)), 
+                    uInt(getBeam(irow)), uInt(getIF(irow)), uInt(getPol(irow)), 
+                    uInt(0), timeSecCol[irow], Bool(true), ftype, fparam, 
+                    Vector<Float>(), maskList, Vector<Float>(params), 
+                    Float(rms), uInt(spec.size()), Float(clipth), uInt(clipn), 
+                    Float(0.0), uInt(0), Vector<uInt>());
+      }
+
+    }
+  }
+
+  if (outBaselineTable) {
+    bt->save(outbltable);
+  }
+  delete bt;
+
+  return res;
+}
+
+std::vector<float> Scantable::doApplyBaselineTable(std::vector<float>& spec, std::vector<bool>& mask, const STBaselineFunc::FuncName ftype, std::vector<int>& fpar, std::vector<float>& params, float&rms)
+{
+  std::vector<bool> finalmask;
+  std::vector<int> lfedge;
+  return doSubtractBaseline(spec, mask, ftype, fpar, params, rms, finalmask, 0.0, 0, false, 0, 0.0, lfedge, 0);
+}
+
+  std::vector<float> Scantable::doSubtractBaseline(std::vector<float>& spec, std::vector<bool>& mask, const STBaselineFunc::FuncName ftype, std::vector<int>& fpar, std::vector<float>& params, float&rms, std::vector<bool>& finalmask, float clipth, int clipn, bool uself, int irow, float lfth, std::vector<int>& lfedge, int lfavg)
+{
+  //---replace mask with (mask AND mask_linefinder).
+  if (uself) {
+    STLineFinder lineFinder = STLineFinder();
+    lineFinder.setOptions(lfth, 3, lfavg);
+
+    int minEdgeSize = getIFNos().size()*2;
+    int edgeSize = lfedge.size();
+    std::vector<int> currentEdge;
+    currentEdge.clear();
+    if (edgeSize >= 2) {
+      int idx = 0;
+      if (edgeSize > 2) {
+        if (edgeSize < minEdgeSize) {
+          throw(AipsError("Length of edge element info is less than that of IFs"));
+        }
+        idx = 2 * getIF(irow);
+      }
+      currentEdge.push_back(lfedge[idx]);
+      currentEdge.push_back(lfedge[idx+1]);
+    } else {
+      throw(AipsError("Wrong length of edge element"));
+    }
+    lineFinder.setData(spec);
+    lineFinder.findLines(getCompositeChanMask(irow, mask), currentEdge, irow);
+
+    std::vector<bool> lfcompmask = lineFinder.getMask();
+    mask.clear();
+    mask.resize(lfcompmask.size());
+    for (uInt i = 0; i < mask.size(); ++i) {
+      mask[i] = lfcompmask[i];
+    }
+  }
+  //---
+
+  std::vector<float> res;
+  if (ftype == STBaselineFunc::Polynomial) {
+    res = doPolynomialFitting(spec, mask, fpar[0], params, rms, finalmask, clipth, clipn);
+  } else if (ftype == STBaselineFunc::Chebyshev) {
+    res = doChebyshevFitting(spec, mask, fpar[0], params, rms, finalmask, clipth, clipn);
+  } else if (ftype == STBaselineFunc::CSpline) {
+    if (fpar.size() > 1) { // reading from baseline table in which pieceEdges are already calculated and stored.
+      res = doCubicSplineFitting(spec, mask, fpar, params, rms, finalmask, clipth, clipn);
+    } else {               // usual cspline fitting by giving nPiece only. fpar will be replaced with pieceEdges. 
+      res = doCubicSplineFitting(spec, mask, fpar[0], fpar, params, rms, finalmask, clipth, clipn);
+    }
+  } else if (ftype == STBaselineFunc::Sinusoid) {
+    res = doSinusoidFitting(spec, mask, fpar, params, rms, finalmask, clipth, clipn);
+  }
+
+  return res;
+}
+
+std::string Scantable::packFittingResults(const int irow, const std::vector<float>& params, const float rms)
+{
+  // returned value: "irow:params[0],params[1],..,params[n-1]:rms"
+  ostringstream os;
+  os << irow << ':';
+  for (uInt i = 0; i < params.size(); ++i) {
+    if (i > 0) {
+      os << ',';
+    }
+    os << params[i];
+  }
+  os << ':' << rms;
+
+  return os.str();
+}
+
+void Scantable::parseBlInfo(const std::string& blInfo, int& irow, STBaselineFunc::FuncName& ftype, std::vector<int>& fpar, std::vector<bool>& mask, float& thresClip, int& nIterClip, bool& useLineFinder, float& thresLF, std::vector<int>& edgeLF, int& avgLF)
+{
+  // The baseline info to be parsed must be column-delimited string like 
+  // "0:chebyshev:5:3,5,169,174,485,487" where the elements are 
+  // row number, funcType, funcOrder, maskList, clipThreshold, clipNIter, 
+  // useLineFinder, lfThreshold, lfEdge and lfChanAvgLimit.
+
+  std::vector<string> res = splitToStringList(blInfo, ':');
+  if (res.size() < 4) {
+    throw(AipsError("baseline info has bad format")) ;
+  }
+
+  string ftype0, fpar0, masklist0, uself0, edge0;
+  std::vector<int> masklist;
+
+  stringstream ss;
+  ss << res[0];
+  ss >> irow;
+  ss.clear(); ss.str("");
+
+  ss << res[1];
+  ss >> ftype0;
+  if (ftype0 == "poly") {
+    ftype = STBaselineFunc::Polynomial;
+  } else if (ftype0 == "cspline") {
+    ftype = STBaselineFunc::CSpline;
+  } else if (ftype0 == "sinusoid") {
+    ftype = STBaselineFunc::Sinusoid;
+  } else if (ftype0 == "chebyshev") {
+    ftype = STBaselineFunc::Chebyshev;
+  } else {
+    throw(AipsError("invalid function type."));
+  }
+  ss.clear(); ss.str("");
+
+  ss << res[2];
+  ss >> fpar0;
+  fpar = splitToIntList(fpar0, ',');
+  ss.clear(); ss.str("");
+
+  ss << res[3];
+  ss >> masklist0;
+  mask = getMaskFromMaskList(nchan(getIF(irow)), splitToIntList(masklist0, ','));
+
+  ss << res[4];
+  ss >> thresClip;
+  ss.clear(); ss.str("");
+
+  ss << res[5];
+  ss >> nIterClip;
+  ss.clear(); ss.str("");
+
+  ss << res[6];
+  ss >> uself0;
+  if (uself0 == "true") {
+    useLineFinder = true;
+  } else {
+    useLineFinder = false;
+  }
+  ss.clear(); ss.str("");
+
+  if (useLineFinder) {
+    ss << res[7];
+    ss >> thresLF;
+    ss.clear(); ss.str("");
+
+    ss << res[8];
+    ss >> edge0;
+    edgeLF = splitToIntList(edge0, ',');
+    ss.clear(); ss.str("");
+
+    ss << res[9];
+    ss >> avgLF;
+    ss.clear(); ss.str("");
+  }
+
+}
+
+std::vector<int> Scantable::splitToIntList(const std::string& s, const char delim)
+{
+  istringstream iss(s);
+  string tmp;
+  int tmpi;
+  std::vector<int> res;
+  stringstream ss;
+  while (getline(iss, tmp, delim)) {
+    ss << tmp;
+    ss >> tmpi;
+    res.push_back(tmpi);
+    ss.clear(); ss.str("");
+  }
+
+  return res;
+}
+
+std::vector<string> Scantable::splitToStringList(const std::string& s, const char delim)
+{
+  istringstream iss(s);
+  std::string tmp;
+  std::vector<string> res;
+  while (getline(iss, tmp, delim)) {
+    res.push_back(tmp);
+  }
+
+  return res;
+}
+
+std::vector<bool> Scantable::getMaskFromMaskList(const int nchan, const std::vector<int>& masklist)
+{
+  if (masklist.size() % 2 != 0) {
+    throw(AipsError("masklist must have even number of elements."));
+  }
+
+  std::vector<bool> res(nchan);
+
+  for (int i = 0; i < nchan; ++i) {
+    res[i] = false;
+  }
+  for (uInt j = 0; j < masklist.size(); j += 2) {
+    for (int i = masklist[j]; i <= masklist[j+1]; ++i) {
+      res[i] = true;
+    }
+  }
+
+  return res;
+}
+
+void Scantable::polyBaseline(const std::vector<bool>& mask, int order, float thresClip, int nIterClip, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile, const std::string& bltable)
+{
+  /****
+  double TimeStart = mathutil::gettimeofday_sec();
+  ****/
+
   try {
     ofstream ofs;
@@ -2511 +2910 @@
     }
 
-    Fitter fitter = Fitter();
-    fitter.setExpression("poly", order);
-    //fitter.setIterClipping(thresClip, nIterClip);
-
-    int nRow = nrow();
-    std::vector<bool> chanMask;
     bool showProgress;
     int minNRow;
     parseProgressInfo(progressInfo, showProgress, minNRow);
 
+    int nRow = nrow();
+    std::vector<bool> chanMask;
+    std::vector<bool> finalChanMask;
+    float rms;
+
+    //---
+    bool outBaselintTable = (bltable != "");
+    STBaselineTable* bt = new STBaselineTable(*this);
+    ROScalarColumn<Double> *tcol = new ROScalarColumn<Double>(table_, "TIME");
+    Vector<Double> timeSecCol = tcol->getColumn();
+    //---
+
     for (int whichrow = 0; whichrow < nRow; ++whichrow) {
+      std::vector<float> sp = getSpectrum(whichrow);
       chanMask = getCompositeChanMask(whichrow, mask);
-      fitBaseline(chanMask, whichrow, fitter);
-      setSpectrum((getResidual ? fitter.getResidual() : fitter.getFit()), whichrow);
-      outputFittingResult(outLogger, outTextFile, csvFormat, chanMask, whichrow, coordInfo, hasSameNchan, ofs, "polyBaseline()", fitter);
+      std::vector<float> params(order+1);
+      int nClipped = 0;
+      std::vector<float> res = doPolynomialFitting(sp, chanMask, order, params, rms, finalChanMask, nClipped, thresClip, nIterClip, getResidual);
+
+      //---
+      if (outBaselintTable) {
+        Vector<Int> fparam(1);
+        fparam[0] = order;
+        std::vector<int> finalMaskList0;
+        finalMaskList0.clear();
+        for (uInt i = 0; i < finalChanMask.size(); ++i) {
+          if (finalChanMask[i]) {
+            if ((i == 0)||(i == finalChanMask.size()-1)) {
+              finalMaskList0.push_back(i);
+            } else {
+              if ((finalChanMask[i])&&(!finalChanMask[i-1])) {
+                finalMaskList0.push_back(i);
+              }
+              if ((finalChanMask[i])&&(!finalChanMask[i+1])) {
+                finalMaskList0.push_back(i);
+              }
+            }
+          }
+        }
+        Vector<uInt> finalMaskList(finalMaskList0.size());
+        for (uInt i = 0; i < finalMaskList0.size(); ++i) {
+          finalMaskList[i] = (uInt)finalMaskList0[i];
+        }
+
+        bt->appenddata(uInt(getScan(whichrow)), uInt(getCycle(whichrow)), uInt(getBeam(whichrow)), uInt(getIF(whichrow)), uInt(getPol(whichrow)), 
+                       uInt(0), 
+                       timeSecCol[whichrow],
+                       Bool(true), 
+                       STBaselineFunc::Polynomial, 
+                       fparam, 
+                       Vector<Float>(),
+                       finalMaskList, 
+                       Vector<Float>(params), 
+                       Float(rms), 
+                       uInt(sp.size()), 
+                       Float(thresClip), 
+                       uInt(nIterClip), 
+                       Float(0.0),
+                       uInt(0),
+                       Vector<uInt>());
+      } else {
+        setSpectrum(res, whichrow);
+      }
+      //---
+
+      outputFittingResult(outLogger, outTextFile, csvFormat, chanMask, whichrow, coordInfo, hasSameNchan, ofs, "chebyshevBaseline()", params, nClipped);
       showProgressOnTerminal(whichrow, nRow, showProgress, minNRow);
     }
+    
+    //---
+    if (outBaselintTable) {
+      bt->save(bltable);
+    }
+    //---
+    delete bt;
 
     if (outTextFile) ofs.close();
@@ -2534 +2995 @@
     throw;
   }
-}
-
-void Scantable::autoPolyBaseline(const std::vector<bool>& mask, int order, const std::vector<int>& edge, float threshold, int chanAvgLimit, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile)
+
+  /****
+  double TimeEnd = mathutil::gettimeofday_sec();
+  double elapse1 = TimeEnd - TimeStart;
+  std::cout << "poly-new   : " << elapse1 << " (sec.)" << endl;
+  ****/
+}
+
+void Scantable::autoPolyBaseline(const std::vector<bool>& mask, int order, float thresClip, int nIterClip, const std::vector<int>& edge, float threshold, int chanAvgLimit, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile, const std::string& bltable)
 {
   try {
@@ -2557 +3024 @@
     }
 
-    Fitter fitter = Fitter();
-    fitter.setExpression("poly", order);
-    //fitter.setIterClipping(thresClip, nIterClip);
-
-    int nRow = nrow();
-    std::vector<bool> chanMask;
+    bool showProgress;
+    int minNRow;
+    parseProgressInfo(progressInfo, showProgress, minNRow);
+
     int minEdgeSize = getIFNos().size()*2;
     STLineFinder lineFinder = STLineFinder();
     lineFinder.setOptions(threshold, 3, chanAvgLimit);
 
-    bool showProgress;
-    int minNRow;
-    parseProgressInfo(progressInfo, showProgress, minNRow);
+    int nRow = nrow();
+    std::vector<bool> chanMask;
+    std::vector<bool> finalChanMask;
+    float rms;
+
+    //---
+    bool outBaselintTable = (bltable != "");
+    STBaselineTable* bt = new STBaselineTable(*this);
+    ROScalarColumn<Double> *tcol = new ROScalarColumn<Double>(table_, "TIME");
+    Vector<Double> timeSecCol = tcol->getColumn();
+    //---
 
     for (int whichrow = 0; whichrow < nRow; ++whichrow) {
-
-      //-------------------------------------------------------
-      //chanMask = getCompositeChanMask(whichrow, mask, edge, minEdgeSize, lineFinder);
-      //-------------------------------------------------------
+      std::vector<float> sp = getSpectrum(whichrow);
+      //-- composote given channel mask and flagtra --------
       int edgeSize = edge.size();
       std::vector<int> currentEdge;
+      currentEdge.clear();
       if (edgeSize >= 2) {
         int idx = 0;
@@ -2591 +3063 @@
         throw(AipsError("Wrong length of edge element"));
       }
-      lineFinder.setData(getSpectrum(whichrow));
+      lineFinder.setData(sp);
       lineFinder.findLines(getCompositeChanMask(whichrow, mask), currentEdge, whichrow);
       chanMask = lineFinder.getMask();
-      //-------------------------------------------------------
-
-      fitBaseline(chanMask, whichrow, fitter);
-      setSpectrum((getResidual ? fitter.getResidual() : fitter.getFit()), whichrow);
-
-      outputFittingResult(outLogger, outTextFile, csvFormat, chanMask, whichrow, coordInfo, hasSameNchan, ofs, "autoPolyBaseline()", fitter);
+      //-- composote given channel mask and flagtra END --------
+
+      std::vector<float> params(order+1);
+      int nClipped = 0;
+      std::vector<float> res = doPolynomialFitting(sp, chanMask, order, params, rms, finalChanMask, nClipped, thresClip, nIterClip, getResidual);
+
+      if (outBaselintTable) {
+        Vector<Int> fparam(1);
+        fparam[0] = order;
+        std::vector<int> finalMaskList0;
+        finalMaskList0.clear();
+        for (uInt i = 0; i < finalChanMask.size(); ++i) {
+          if (finalChanMask[i]) {
+            if ((i == 0)||(i == finalChanMask.size()-1)) {
+              finalMaskList0.push_back(i);
+            } else {
+              if ((finalChanMask[i])&&(!finalChanMask[i-1])) {
+                finalMaskList0.push_back(i);
+              }
+              if ((finalChanMask[i])&&(!finalChanMask[i+1])) {
+                finalMaskList0.push_back(i);
+              }
+            }
+          }
+        }
+        Vector<uInt> finalMaskList(finalMaskList0.size());
+        for (uInt i = 0; i < finalMaskList0.size(); ++i) {
+          finalMaskList[i] = (uInt)finalMaskList0[i];
+        }
+
+        Vector<uInt> cEdge(currentEdge.size());
+        for (uInt i = 0; i < currentEdge.size(); ++i) {
+          cEdge[i] = currentEdge[i];
+        }
+
+        bt->appenddata(uInt(getScan(whichrow)), uInt(getCycle(whichrow)), uInt(getBeam(whichrow)), uInt(getIF(whichrow)), uInt(getPol(whichrow)), 
+                       uInt(0), 
+                       timeSecCol[whichrow],
+                       Bool(true), 
+                       STBaselineFunc::Polynomial, 
+                       fparam, 
+                       Vector<Float>(), 
+                       finalMaskList, 
+                       Vector<Float>(params), 
+                       Float(rms),
+                       uInt(sp.size()), 
+                       Float(thresClip), 
+                       uInt(nIterClip), 
+                       Float(threshold),
+                       uInt(chanAvgLimit),
+                       cEdge);
+      } else {
+        setSpectrum(res, whichrow);
+      }
+
+      outputFittingResult(outLogger, outTextFile, csvFormat, chanMask, whichrow, coordInfo, hasSameNchan, ofs, "autoChebyshevBaseline()", params, nClipped);
       showProgressOnTerminal(whichrow, nRow, showProgress, minNRow);
     }
+
+    //---
+    if (outBaselintTable) {
+      bt->save(bltable);
+    }
+    //---
+    delete bt;
 
     if (outTextFile) ofs.close();
@@ -2610 +3139 @@
 }
 
-void Scantable::chebyshevBaseline(const std::vector<bool>& mask, int order, float thresClip, int nIterClip, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile)
-{
+void Scantable::chebyshevBaseline(const std::vector<bool>& mask, int order, float thresClip, int nIterClip, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile, const std::string& bltable)
+{
+  //
+  double TimeStart = mathutil::gettimeofday_sec();
+  //
+
   try {
     ofstream ofs;
@@ -2641 +3174 @@
 
     //---
-    bool outBaselineParamTable = false;
+    bool outBaselintTable = (bltable != "");
     STBaselineTable* bt = new STBaselineTable(*this);
+    ROScalarColumn<Double> *tcol = new ROScalarColumn<Double>(table_, "TIME");
+    Vector<Double> timeSecCol = tcol->getColumn();
     //---
 
@@ -2650 +3185 @@
       std::vector<float> params(order+1);
       int nClipped = 0;
-      std::vector<float> res = doChebyshevFitting(sp, chanMask, order, params, finalChanMask, rms, nClipped, thresClip, nIterClip, getResidual);
+      std::vector<float> res = doChebyshevFitting(sp, chanMask, order, params, rms, finalChanMask, nClipped, thresClip, nIterClip, getResidual);
 
       //---
-      if (outBaselineParamTable) {
+      if (outBaselintTable) {
+        Vector<Int> fparam(1);
+        fparam[0] = order;
+        std::vector<int> finalMaskList0;
+        finalMaskList0.clear();
+        for (uInt i = 0; i < finalChanMask.size(); ++i) {
+          if (finalChanMask[i]) {
+            if ((i == 0)||(i == finalChanMask.size()-1)) {
+              finalMaskList0.push_back(i);
+            } else {
+              if ((finalChanMask[i])&&(!finalChanMask[i-1])) {
+                finalMaskList0.push_back(i);
+              }
+              if ((finalChanMask[i])&&(!finalChanMask[i+1])) {
+                finalMaskList0.push_back(i);
+              }
+            }
+          }
+        }
+        Vector<uInt> finalMaskList(finalMaskList0.size());
+        for (uInt i = 0; i < finalMaskList0.size(); ++i) {
+          finalMaskList[i] = (uInt)finalMaskList0[i];
+        }
+
         bt->appenddata(uInt(getScan(whichrow)), uInt(getCycle(whichrow)), uInt(getBeam(whichrow)), uInt(getIF(whichrow)), uInt(getPol(whichrow)), 
                        uInt(0), 
-                       Double(0.0), // <-- Double(getTime(whichrow, false)), 
-                       uInt(nchan(whichrow)), 
+                       timeSecCol[whichrow],
+                       Bool(true), 
                        STBaselineFunc::Chebyshev, 
-                       Vector<uInt>(1), // ==> MUST BE Vector<uInt> containing 'order'.
-                       Vector<Float>(), // ==> for ffpar. ** dummy **
+                       fparam, 
+                       Vector<Float>(),
+                       finalMaskList, 
+                       Vector<Float>(params), 
+                       Float(rms), 
+                       uInt(sp.size()), 
+                       Float(thresClip), 
                        uInt(nIterClip), 
-                       Float(thresClip), 
-                       Vector<uInt>(5), // <-- Vector<uInt>(finalChanMask), 
-                       Vector<Float>(params), 
-                       Float(rms));
+                       Float(0.0),
+                       uInt(0),
+                       Vector<uInt>());
       } else {
         setSpectrum(res, whichrow);
@@ -2676 +3238 @@
     
     //---
-    if (outBaselineParamTable) {
-      bt->save("chebyparamtable");
+    if (outBaselintTable) {
+      bt->save(bltable);
     }
     //---
@@ -2687 +3249 @@
     throw;
   }
+
+  double TimeEnd = mathutil::gettimeofday_sec();
+  double elapse1 = TimeEnd - TimeStart;
+  std::cout << "cheby   : " << elapse1 << " (sec.)" << endl;
+}
+
+void Scantable::autoChebyshevBaseline(const std::vector<bool>& mask, int order, float thresClip, int nIterClip, const std::vector<int>& edge, float threshold, int chanAvgLimit, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile, const std::string& bltable)
+{
+  try {
+    ofstream ofs;
+    String coordInfo = "";
+    bool hasSameNchan = true;
+    bool outTextFile = false;
+    bool csvFormat = false;
+
+    if (blfile != "") {
+      csvFormat = (blfile.substr(0, 1) == "T");
+      ofs.open(blfile.substr(1).c_str(), ios::out | ios::app);
+      if (ofs) outTextFile = true;
+    }
+
+    if (outLogger || outTextFile) {
+      coordInfo = getCoordInfo()[0];
+      if (coordInfo == "") coordInfo = "channel";
+      hasSameNchan = hasSameNchanOverIFs();
+    }
+
+    bool showProgress;
+    int minNRow;
+    parseProgressInfo(progressInfo, showProgress, minNRow);
+
+    int minEdgeSize = getIFNos().size()*2;
+    STLineFinder lineFinder = STLineFinder();
+    lineFinder.setOptions(threshold, 3, chanAvgLimit);
+
+    int nRow = nrow();
+    std::vector<bool> chanMask;
+    std::vector<bool> finalChanMask;
+    float rms;
+
+    //---
+    bool outBaselintTable = (bltable != "");
+    STBaselineTable* bt = new STBaselineTable(*this);
+    ROScalarColumn<Double> *tcol = new ROScalarColumn<Double>(table_, "TIME");
+    Vector<Double> timeSecCol = tcol->getColumn();
+    //---
+
+    for (int whichrow = 0; whichrow < nRow; ++whichrow) {
+      std::vector<float> sp = getSpectrum(whichrow);
+      //-- composote given channel mask and flagtra --------
+      int edgeSize = edge.size();
+      std::vector<int> currentEdge;
+      currentEdge.clear();
+      if (edgeSize >= 2) {
+        int idx = 0;
+        if (edgeSize > 2) {
+          if (edgeSize < minEdgeSize) {
+            throw(AipsError("Length of edge element info is less than that of IFs"));
+          }
+          idx = 2 * getIF(whichrow);
+        }
+        currentEdge.push_back(edge[idx]);
+        currentEdge.push_back(edge[idx+1]);
+      } else {
+        throw(AipsError("Wrong length of edge element"));
+      }
+      lineFinder.setData(sp);
+      lineFinder.findLines(getCompositeChanMask(whichrow, mask), currentEdge, whichrow);
+      chanMask = lineFinder.getMask();
+      //-- composote given channel mask and flagtra END --------
+
+      std::vector<float> params(order+1);
+      int nClipped = 0;
+      std::vector<float> res = doChebyshevFitting(sp, chanMask, order, params, rms, finalChanMask, nClipped, thresClip, nIterClip, getResidual);
+
+      if (outBaselintTable) {
+        Vector<Int> fparam(1);
+        fparam[0] = order;
+        std::vector<int> finalMaskList0;
+        finalMaskList0.clear();
+        for (uInt i = 0; i < finalChanMask.size(); ++i) {
+          if (finalChanMask[i]) {
+            if ((i == 0)||(i == finalChanMask.size()-1)) {
+              finalMaskList0.push_back(i);
+            } else {
+              if ((finalChanMask[i])&&(!finalChanMask[i-1])) {
+                finalMaskList0.push_back(i);
+              }
+              if ((finalChanMask[i])&&(!finalChanMask[i+1])) {
+                finalMaskList0.push_back(i);
+              }
+            }
+          }
+        }
+        Vector<uInt> finalMaskList(finalMaskList0.size());
+        for (uInt i = 0; i < finalMaskList0.size(); ++i) {
+          finalMaskList[i] = (uInt)finalMaskList0[i];
+        }
+
+        Vector<uInt> cEdge(currentEdge.size());
+        for (uInt i = 0; i < currentEdge.size(); ++i) {
+          cEdge[i] = currentEdge[i];
+        }
+
+        bt->appenddata(uInt(getScan(whichrow)), uInt(getCycle(whichrow)), uInt(getBeam(whichrow)), uInt(getIF(whichrow)), uInt(getPol(whichrow)), 
+                       uInt(0), 
+                       timeSecCol[whichrow],
+                       Bool(true), 
+                       STBaselineFunc::Chebyshev, 
+                       fparam, 
+                       Vector<Float>(), 
+                       finalMaskList, 
+                       Vector<Float>(params), 
+                       Float(rms),
+                       uInt(sp.size()), 
+                       Float(thresClip), 
+                       uInt(nIterClip), 
+                       Float(threshold),
+                       uInt(chanAvgLimit),
+                       cEdge);
+      } else {
+        setSpectrum(res, whichrow);
+      }
+
+      outputFittingResult(outLogger, outTextFile, csvFormat, chanMask, whichrow, coordInfo, hasSameNchan, ofs, "autoChebyshevBaseline()", params, nClipped);
+      showProgressOnTerminal(whichrow, nRow, showProgress, minNRow);
+    }
+
+    //---
+    if (outBaselintTable) {
+      bt->save(bltable);
+    }
+    //---
+    delete bt;
+
+    if (outTextFile) ofs.close();
+
+  } catch (...) {
+    throw;
+  }
 }
 
 double Scantable::calculateModelSelectionCriteria(const std::string& valname, const std::string& blfunc, int order, const std::vector<bool>& inMask, int whichrow, bool useLineFinder, const std::vector<int>& edge, float threshold, int chanAvgLimit)
 {
+  std::vector<float> sp = getSpectrum(whichrow);
+  std::vector<bool> chanMask;
+  chanMask.clear();
+
   if (useLineFinder) {
     int minEdgeSize = getIFNos().size()*2;
 
-
     int edgeSize = edge.size();
     std::vector<int> currentEdge;
+    currentEdge.clear();
     if (edgeSize >= 2) {
       int idx = 0;
@@ -2712 +3418 @@
 
     STLineFinder lineFinder = STLineFinder();
-    std::vector<float> sp = getSpectrum(whichrow);
     lineFinder.setData(sp);
     lineFinder.setOptions(threshold, 3, chanAvgLimit);
     lineFinder.findLines(getCompositeChanMask(whichrow, inMask), currentEdge, whichrow);
-    std::vector<bool> chanMask = lineFinder.getMask();
-    
-    return doCalculateModelSelectionCriteria(valname, sp, chanMask, blfunc, order);
+    chanMask = lineFinder.getMask();
 
   } else {
-    return doCalculateModelSelectionCriteria(valname, getSpectrum(whichrow), getCompositeChanMask(whichrow, inMask), blfunc, order);
-  }
-
+
+    chanMask = getCompositeChanMask(whichrow, inMask);
+  }
+
+  return doCalculateModelSelectionCriteria(valname, sp, chanMask, blfunc, order);
 }
 
@@ -2733 +3438 @@
   float rms;
   int nClipped = 0;
-  float thresClip = 0.0;
-  int nIterClip = 0;
   std::vector<float> res;
-  if (blfunc == "chebyshev") {
+  if (blfunc == "poly") {
     nparam = order + 1;
-    res = doChebyshevFitting(spec, mask, order, params, finalChanMask, rms, nClipped, thresClip, nIterClip, true);
+    res = doPolynomialFitting(spec, mask, order, params, rms, finalChanMask, nClipped);
+  } else if (blfunc == "chebyshev") {
+    nparam = order + 1;
+    res = doChebyshevFitting(spec, mask, order, params, rms, finalChanMask, nClipped);
+  } else if (blfunc == "cspline") {
+    std::vector<int> pieceEdges;//(order+1);  //order = npiece
+    nparam = order + 3;
+    //params.resize(4*order);
+    res = doCubicSplineFitting(spec, mask, order, false, pieceEdges, params, rms, finalChanMask, nClipped);
   } else if (blfunc == "sinusoid") {
     std::vector<int> nWaves;
@@ -2746 +3457 @@
     }
     nparam = 2*order + 1;  // order = nwave
-    res = doSinusoidFitting(spec, mask, nWaves, params, nClipped, thresClip, nIterClip, true);
-  } else if (blfunc == "cspline") {
-    std::vector<int> pieceEdges(order+1);  //order = npiece
-    nparam = order + 3;
-    params.resize(4*order);
-    res = doCubicSplineFitting(spec, mask, order, pieceEdges, params, nClipped, thresClip, nIterClip, true);
+    res = doSinusoidFitting(spec, mask, nWaves, params, rms, finalChanMask, nClipped);
   } else {
-    throw(AipsError("blfunc must be chebyshev, cspline or sinusoid."));
+    throw(AipsError("blfunc must be poly, chebyshev, cspline or sinusoid."));
   }
 
@@ -2777 +3483 @@
     double aic = nusedchan * (log(2.0 * PI * msq) + 1.0) + 2.0 * nparam;
 
-    // Corrected AIC by Sugiura(1978)
+    // Corrected AIC by Sugiura(1978) (AICc)
     if (valname == "aicc") {
       if (nusedchan - nparam - 1 <= 0) {
@@ -2803 +3509 @@
 }
 
-void Scantable::autoChebyshevBaseline(const std::vector<bool>& mask, int order, float thresClip, int nIterClip, const std::vector<int>& edge, float threshold, int chanAvgLimit, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile)
-{
-  try {
-    ofstream ofs;
-    String coordInfo = "";
-    bool hasSameNchan = true;
-    bool outTextFile = false;
-    bool csvFormat = false;
-
-    if (blfile != "") {
-      csvFormat = (blfile.substr(0, 1) == "T");
-      ofs.open(blfile.substr(1).c_str(), ios::out | ios::app);
-      if (ofs) outTextFile = true;
-    }
-
-    if (outLogger || outTextFile) {
-      coordInfo = getCoordInfo()[0];
-      if (coordInfo == "") coordInfo = "channel";
-      hasSameNchan = hasSameNchanOverIFs();
-    }
-
-    int nRow = nrow();
-    std::vector<bool> chanMask;
-    int minEdgeSize = getIFNos().size()*2;
-    STLineFinder lineFinder = STLineFinder();
-    lineFinder.setOptions(threshold, 3, chanAvgLimit);
-
-    bool showProgress;
-    int minNRow;
-    parseProgressInfo(progressInfo, showProgress, minNRow);
-
-    std::vector<bool> finalChanMask;
-    float rms;
-
-    for (int whichrow = 0; whichrow < nRow; ++whichrow) {
-      std::vector<float> sp = getSpectrum(whichrow);
-
-      //-------------------------------------------------------
-      //chanMask = getCompositeChanMask(whichrow, mask, edge, minEdgeSize, lineFinder);
-      //-------------------------------------------------------
-      int edgeSize = edge.size();
-      std::vector<int> currentEdge;
-      if (edgeSize >= 2) {
-        int idx = 0;
-        if (edgeSize > 2) {
-          if (edgeSize < minEdgeSize) {
-            throw(AipsError("Length of edge element info is less than that of IFs"));
-          }
-          idx = 2 * getIF(whichrow);
-        }
-        currentEdge.push_back(edge[idx]);
-        currentEdge.push_back(edge[idx+1]);
-      } else {
-        throw(AipsError("Wrong length of edge element"));
-      }
-      //lineFinder.setData(getSpectrum(whichrow));
-      lineFinder.setData(sp);
-      lineFinder.findLines(getCompositeChanMask(whichrow, mask), currentEdge, whichrow);
-      chanMask = lineFinder.getMask();
-      //-------------------------------------------------------
-
-
-      //fitBaseline(chanMask, whichrow, fitter);
-      //setSpectrum((getResidual ? fitter.getResidual() : fitter.getFit()), whichrow);
-      std::vector<float> params(order+1);
-      int nClipped = 0;
-      std::vector<float> res = doChebyshevFitting(sp, chanMask, order, params, finalChanMask, rms, nClipped, thresClip, nIterClip, getResidual);
-      setSpectrum(res, whichrow);
-
-      outputFittingResult(outLogger, outTextFile, csvFormat, chanMask, whichrow, coordInfo, hasSameNchan, ofs, "autoChebyshevBaseline()", params, nClipped);
-      showProgressOnTerminal(whichrow, nRow, showProgress, minNRow);
-    }
-
-    if (outTextFile) ofs.close();
-
-  } catch (...) {
-    throw;
-  }
-}
-
-  /*
-double Scantable::getChebyshevPolynomial(int n, double x) {
-  if ((x < -1.0)||(x > 1.0)) {
-    throw(AipsError("out of definition range (-1 <= x <= 1)."));
-  } else if (n < 0) {
-    throw(AipsError("the order must be zero or positive."));
-  } else if (n == 0) {
+double Scantable::getNormalPolynomial(int n, double x) {
+  if (n == 0) {
     return 1.0;
-  } else if (n == 1) {
-    return x;
+  } else if (n > 0) {
+    double res = 1.0;
+    for (int i = 0; i < n; ++i) {
+      res *= x;
+    }
+    return res;
   } else {
-    return 2.0*x*getChebyshevPolynomial(n-1, x) - getChebyshevPolynomial(n-2, x);
-  }
-}
-  */
+    if (x == 0.0) {
+      throw(AipsError("infinity result: x=0 given for negative power."));
+    } else {
+      return pow(x, (double)n);
+    }
+  }
+}
+
 double Scantable::getChebyshevPolynomial(int n, double x) {
   if ((x < -1.0)||(x > 1.0)) {
@@ -2939 +3568 @@
 }
 
-std::vector<float> Scantable::doChebyshevFitting(const std::vector<float>& data, const std::vector<bool>& mask, int order, std::vector<float>& params, std::vector<bool>& finalMask, float& rms, int& nClipped, float thresClip, int nIterClip, bool getResidual)
+std::vector<float> Scantable::doPolynomialFitting(const std::vector<float>& data, const std::vector<bool>& mask, int order, std::vector<float>& params, float& rms, std::vector<bool>& finalmask, float clipth, int clipn)
+{
+  int nClipped = 0;
+  return doPolynomialFitting(data, mask, order, params, rms, finalmask, nClipped, clipth, clipn);
+}
+
+std::vector<float> Scantable::doPolynomialFitting(const std::vector<float>& data, const std::vector<bool>& mask, int order, std::vector<float>& params, float& rms, std::vector<bool>& finalMask, int& nClipped, float thresClip, int nIterClip, bool getResidual)
+{
+  return doLeastSquareFitting(data, mask, &Scantable::getNormalPolynomial, order, params, rms, finalMask, nClipped, thresClip, nIterClip, getResidual);
+}
+
+std::vector<float> Scantable::doChebyshevFitting(const std::vector<float>& data, const std::vector<bool>& mask, int order, std::vector<float>& params, float& rms, std::vector<bool>& finalmask, float clipth, int clipn)
+{
+  int nClipped = 0;
+  return doChebyshevFitting(data, mask, order, params, rms, finalmask, nClipped, clipth, clipn);
+}
+
+std::vector<float> Scantable::doChebyshevFitting(const std::vector<float>& data, const std::vector<bool>& mask, int order, std::vector<float>& params, float& rms, std::vector<bool>& finalMask, int& nClipped, float thresClip, int nIterClip, bool getResidual)
+{
+  return doLeastSquareFitting(data, mask, &Scantable::getChebyshevPolynomial, order, params, rms, finalMask, nClipped, thresClip, nIterClip, getResidual);
+}
+
+std::vector<float> Scantable::doLeastSquareFitting(const std::vector<float>& data, const std::vector<bool>& mask, double (Scantable::*pfunc)(int, double), int order, std::vector<float>& params, float& rms, std::vector<bool>& finalMask, int& nClipped, float thresClip, int nIterClip, bool getResidual)
 {
   if (data.size() != mask.size()) {
@@ -2945 +3596 @@
   }
   if (order < 0) {
-    throw(AipsError("maximum order of Chebyshev polynomial must not be negative."));
+    throw(AipsError("maximum order of polynomial must not be negative."));
   }
 
@@ -2971 +3622 @@
   //          xArray.size() is nDOF and xArray[*].size() is nChan. 
   //          Each xArray element are as follows:
+  //
+  //          (for normal polynomials)
+  //          xArray[0]   = {1.0,   1.0,   1.0,   ..., 1.0},
+  //          xArray[1]   = {0.0,   1.0,   2.0,   ..., (nChan-1)}
+  //          xArray[n-1] = ...,
+  //          xArray[n]   = {0.0^n, 1.0^n, 2.0^n, ..., (nChan-1)^n}
+  //          where (0 <= n <= order)
+  //
+  //          (for Chebyshev polynomials)
   //          xArray[0]   = {T0(-1), T0(2/(nChan-1)-1), T0(4/(nChan-1)-1), ..., T0(1)}, 
   //          xArray[n-1] = ...,
@@ -2976 +3636 @@
   //          where (0 <= n <= order),
   std::vector<std::vector<double> > xArray;
+  double xFactor, xShift;
+  if (pfunc == &Scantable::getChebyshevPolynomial) {
+    xFactor = 2.0/(double)(nChan - 1);
+    xShift  = -1.0;
+  } else {
+    xFactor = 1.0;
+    xShift  = 0.0;
+  }
   for (int i = 0; i < nDOF; ++i) {
-    double xFactor = 2.0/(double)(nChan - 1);
     std::vector<double> xs;
     xs.clear();
     for (int j = 0; j < nChan; ++j) {
-      xs.push_back(getChebyshevPolynomial(i, xFactor*(double)j-1.0));
+      xs.push_back((this->*pfunc)(i, xFactor*(double)j + xShift)); 
     }
     xArray.push_back(xs);
@@ -3063 +3730 @@
       }
     }
-    //compute a vector y which consists of the coefficients of the sinusoids forming the 
-    //best-fit curves (a0,s1,c1,s2,c2,...), where a0 is constant and s* and c* are of sine 
-    //and cosine functions, respectively. 
+    //compute a vector y which consists of the coefficients of Chebyshev polynomials. 
     std::vector<double> y;
     params.clear();
@@ -3118 +3783 @@
 
   std::vector<float> result;
+  result.clear();
   if (getResidual) {
     for (int i = 0; i < nChan; ++i) {
@@ -3131 +3797 @@
 }
 
-void Scantable::cubicSplineBaseline(const std::vector<bool>& mask, int nPiece, float thresClip, int nIterClip, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile)
-{
-  /*************
-  double totTimeStart, totTimeEnd, blTimeStart, blTimeEnd, ioTimeStart, ioTimeEnd, msTimeStart, msTimeEnd, seTimeStart, seTimeEnd, otTimeStart, otTimeEnd, prTimeStart, prTimeEnd;
-  double elapseMs = 0.0;
-  double elapseSe = 0.0;
-  double elapseOt = 0.0;
-  double elapsePr = 0.0;
-  double elapseBl = 0.0;
-  double elapseIo = 0.0;
-  totTimeStart = mathutil::gettimeofday_sec();
-  *************/
-
+void Scantable::cubicSplineBaseline(const std::vector<bool>& mask, int nPiece, float thresClip, int nIterClip, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile, const std::string& bltable)
+{
   try {
     ofstream ofs;
@@ -3163 +3818 @@
     }
 
-    //Fitter fitter = Fitter();
-    //fitter.setExpression("cspline", nPiece);
-    //fitter.setIterClipping(thresClip, nIterClip);
-
     bool showProgress;
     int minNRow;
@@ -3173 +3824 @@
     int nRow = nrow();
     std::vector<bool> chanMask;
-
-    //--------------------------------
+    std::vector<bool> finalChanMask;
+    float rms;
+
+    //---
+    bool outBaselintTable = (bltable != "");
+    STBaselineTable* bt = new STBaselineTable(*this);
+    ROScalarColumn<Double> *tcol = new ROScalarColumn<Double>(table_, "TIME");
+    Vector<Double> timeSecCol = tcol->getColumn();
+    //---
+
+
     for (int whichrow = 0; whichrow < nRow; ++whichrow) {
-      /******************
-      ioTimeStart = mathutil::gettimeofday_sec();
-      **/
       std::vector<float> sp = getSpectrum(whichrow);
-      /**
-      ioTimeEnd = mathutil::gettimeofday_sec();
-      elapseIo += (double)(ioTimeEnd - ioTimeStart);
-      msTimeStart = mathutil::gettimeofday_sec();
-      ******************/
-
       chanMask = getCompositeChanMask(whichrow, mask);
-
-      /**
-      msTimeEnd = mathutil::gettimeofday_sec();
-      elapseMs += (double)(msTimeEnd - msTimeStart);
-      blTimeStart = mathutil::gettimeofday_sec();
-      **/
-
-      //fitBaseline(chanMask, whichrow, fitter);
-      //setSpectrum((getResidual ? fitter.getResidual() : fitter.getFit()), whichrow);
-      std::vector<int> pieceEdges(nPiece+1);
-      std::vector<float> params(nPiece*4);
+      std::vector<int> pieceEdges;//(nPiece+1);
+      std::vector<float> params;//(nPiece*4);
       int nClipped = 0;
-      std::vector<float> res = doCubicSplineFitting(sp, chanMask, nPiece, pieceEdges, params, nClipped, thresClip, nIterClip, getResidual);
-
-      /**
-      blTimeEnd = mathutil::gettimeofday_sec();
-      elapseBl += (double)(blTimeEnd - blTimeStart);
-      seTimeStart = mathutil::gettimeofday_sec();
-      **/
-
-
-      setSpectrum(res, whichrow);
-      //
-
-      /**
-      seTimeEnd = mathutil::gettimeofday_sec();
-      elapseSe += (double)(seTimeEnd - seTimeStart);
-      otTimeStart = mathutil::gettimeofday_sec();
-      **/
+      std::vector<float> res = doCubicSplineFitting(sp, chanMask, nPiece, false, pieceEdges, params, rms, finalChanMask, nClipped, thresClip, nIterClip, getResidual);
+
+      //---
+      if (outBaselintTable) {
+        Vector<Int> fparam(nPiece);
+        for (uInt i = 0; i < fparam.size(); ++i) {
+          fparam[i] = pieceEdges[i];
+        }
+        std::vector<int> finalMaskList0;
+        finalMaskList0.clear();
+        for (uInt i = 0; i < finalChanMask.size(); ++i) {
+          if (finalChanMask[i]) {
+            if ((i == 0)||(i == finalChanMask.size()-1)) {
+              finalMaskList0.push_back(i);
+            } else {
+              if ((finalChanMask[i])&&(!finalChanMask[i-1])) {
+                finalMaskList0.push_back(i);
+              }
+              if ((finalChanMask[i])&&(!finalChanMask[i+1])) {
+                finalMaskList0.push_back(i);
+              }
+            }
+          }
+        }
+        Vector<uInt> finalMaskList(finalMaskList0.size());
+        for (uInt i = 0; i < finalMaskList0.size(); ++i) {
+          finalMaskList[i] = (uInt)finalMaskList0[i];
+        }
+
+        bt->appenddata(uInt(getScan(whichrow)), uInt(getCycle(whichrow)), uInt(getBeam(whichrow)), uInt(getIF(whichrow)), uInt(getPol(whichrow)), 
+                       uInt(0), 
+                       timeSecCol[whichrow],
+                       Bool(true), 
+                       STBaselineFunc::CSpline, 
+                       fparam, 
+                       Vector<Float>(),
+                       finalMaskList, 
+                       Vector<Float>(params), 
+                       Float(rms), 
+                       uInt(sp.size()), 
+                       Float(thresClip), 
+                       uInt(nIterClip), 
+                       Float(0.0),
+                       uInt(0),
+                       Vector<uInt>());
+      } else {
+        setSpectrum(res, whichrow);
+      }
+      //---
 
       outputFittingResult(outLogger, outTextFile, csvFormat, chanMask, whichrow, coordInfo, hasSameNchan, ofs, "cubicSplineBaseline()", pieceEdges, params, nClipped);
-
-      /**
-      otTimeEnd = mathutil::gettimeofday_sec();
-      elapseOt += (double)(otTimeEnd - otTimeStart);
-      prTimeStart = mathutil::gettimeofday_sec();
-      **/
-
       showProgressOnTerminal(whichrow, nRow, showProgress, minNRow);
-
-      /******************
-      prTimeEnd = mathutil::gettimeofday_sec();
-      elapsePr += (double)(prTimeEnd - prTimeStart);
-      ******************/
-    }
-    //--------------------------------
+    }
     
+    //---
+    if (outBaselintTable) {
+      bt->save(bltable);
+    }
+    //---
+    delete bt;
+
     if (outTextFile) ofs.close();
 
@@ -3239 +3907 @@
     throw;
   }
-  /***************
-  totTimeEnd = mathutil::gettimeofday_sec();
-  std::cout << "io    : " << elapseIo << " (sec.)" << endl;
-  std::cout << "ms    : " << elapseMs << " (sec.)" << endl;
-  std::cout << "bl    : " << elapseBl << " (sec.)" << endl;
-  std::cout << "se    : " << elapseSe << " (sec.)" << endl;
-  std::cout << "ot    : " << elapseOt << " (sec.)" << endl;
-  std::cout << "pr    : " << elapsePr << " (sec.)" << endl;
-  std::cout << "total : " << (double)(totTimeEnd - totTimeStart) << " (sec.)" << endl;
-  ***************/
-}
-
-void Scantable::autoCubicSplineBaseline(const std::vector<bool>& mask, int nPiece, float thresClip, int nIterClip, const std::vector<int>& edge, float threshold, int chanAvgLimit, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile)
+}
+
+void Scantable::autoCubicSplineBaseline(const std::vector<bool>& mask, int nPiece, float thresClip, int nIterClip, const std::vector<int>& edge, float threshold, int chanAvgLimit, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile, const std::string& bltable)
 {
   try {
@@ -3272 +3930 @@
     }
 
-    //Fitter fitter = Fitter();
-    //fitter.setExpression("cspline", nPiece);
-    //fitter.setIterClipping(thresClip, nIterClip);
-
-    int nRow = nrow();
-    std::vector<bool> chanMask;
+    bool showProgress;
+    int minNRow;
+    parseProgressInfo(progressInfo, showProgress, minNRow);
+
     int minEdgeSize = getIFNos().size()*2;
     STLineFinder lineFinder = STLineFinder();
     lineFinder.setOptions(threshold, 3, chanAvgLimit);
 
-    bool showProgress;
-    int minNRow;
-    parseProgressInfo(progressInfo, showProgress, minNRow);
+    int nRow = nrow();
+    std::vector<bool> chanMask;
+    std::vector<bool> finalChanMask;
+    float rms;
+
+    //---
+    bool outBaselintTable = (bltable != "");
+    STBaselineTable* bt = new STBaselineTable(*this);
+    ROScalarColumn<Double> *tcol = new ROScalarColumn<Double>(table_, "TIME");
+    Vector<Double> timeSecCol = tcol->getColumn();
+    //---
 
     for (int whichrow = 0; whichrow < nRow; ++whichrow) {
       std::vector<float> sp = getSpectrum(whichrow);
-
-      //-------------------------------------------------------
-      //chanMask = getCompositeChanMask(whichrow, mask, edge, minEdgeSize, lineFinder);
-      //-------------------------------------------------------
+      //-- composote given channel mask and flagtra --------
       int edgeSize = edge.size();
       std::vector<int> currentEdge;
+      currentEdge.clear();
       if (edgeSize >= 2) {
         int idx = 0;
@@ -3307 +3969 @@
         throw(AipsError("Wrong length of edge element"));
       }
-      //lineFinder.setData(getSpectrum(whichrow));
       lineFinder.setData(sp);
       lineFinder.findLines(getCompositeChanMask(whichrow, mask), currentEdge, whichrow);
       chanMask = lineFinder.getMask();
-      //-------------------------------------------------------
-
-
-      //fitBaseline(chanMask, whichrow, fitter);
-      //setSpectrum((getResidual ? fitter.getResidual() : fitter.getFit()), whichrow);
-      std::vector<int> pieceEdges(nPiece+1);
-      std::vector<float> params(nPiece*4);
+      //-- composote given channel mask and flagtra END --------
+
+      std::vector<int> pieceEdges;//(nPiece+1);
+      std::vector<float> params;//(nPiece*4);
       int nClipped = 0;
-      std::vector<float> res = doCubicSplineFitting(sp, chanMask, nPiece, pieceEdges, params, nClipped, thresClip, nIterClip, getResidual);
-      setSpectrum(res, whichrow);
-      //
+      std::vector<float> res = doCubicSplineFitting(sp, chanMask, nPiece, false, pieceEdges, params, rms, finalChanMask, nClipped, thresClip, nIterClip, getResidual);
+
+      if (outBaselintTable) {
+        Vector<Int> fparam(nPiece);
+        for (uInt i = 0; i < fparam.size(); ++i) {
+          fparam[i] = pieceEdges[i];
+        }
+        std::vector<int> finalMaskList0;
+        finalMaskList0.clear();
+        for (uInt i = 0; i < finalChanMask.size(); ++i) {
+          if (finalChanMask[i]) {
+            if ((i == 0)||(i == finalChanMask.size()-1)) {
+              finalMaskList0.push_back(i);
+            } else {
+              if ((finalChanMask[i])&&(!finalChanMask[i-1])) {
+                finalMaskList0.push_back(i);
+              }
+              if ((finalChanMask[i])&&(!finalChanMask[i+1])) {
+                finalMaskList0.push_back(i);
+              }
+            }
+          }
+        }
+        Vector<uInt> finalMaskList(finalMaskList0.size());
+        for (uInt i = 0; i < finalMaskList0.size(); ++i) {
+          finalMaskList[i] = (uInt)finalMaskList0[i];
+        }
+
+        Vector<uInt> cEdge(currentEdge.size());
+        for (uInt i = 0; i < currentEdge.size(); ++i) {
+          cEdge[i] = currentEdge[i];
+        }
+
+        bt->appenddata(uInt(getScan(whichrow)), uInt(getCycle(whichrow)), uInt(getBeam(whichrow)), uInt(getIF(whichrow)), uInt(getPol(whichrow)), 
+                       uInt(0), 
+                       timeSecCol[whichrow],
+                       Bool(true), 
+                       STBaselineFunc::CSpline, 
+                       fparam, 
+                       Vector<Float>(), 
+                       finalMaskList, 
+                       Vector<Float>(params), 
+                       Float(rms), 
+                       uInt(sp.size()), 
+                       Float(thresClip), 
+                       uInt(nIterClip), 
+                       Float(threshold),
+                       uInt(chanAvgLimit),
+                       cEdge);
+      } else {
+        setSpectrum(res, whichrow);
+      }
 
       outputFittingResult(outLogger, outTextFile, csvFormat, chanMask, whichrow, coordInfo, hasSameNchan, ofs, "autoCubicSplineBaseline()", pieceEdges, params, nClipped);
@@ -3327 +4034 @@
     }
 
+    //---
+    if (outBaselintTable) {
+      bt->save(bltable);
+    }
+    //---
+    delete bt;
+
     if (outTextFile) ofs.close();
 
@@ -3334 +4048 @@
 }
 
-std::vector<float> Scantable::doCubicSplineFitting(const std::vector<float>& data, const std::vector<bool>& mask, int nPiece, std::vector<int>& idxEdge, std::vector<float>& params, int& nClipped, float thresClip, int nIterClip, bool getResidual)
+std::vector<float> Scantable::doCubicSplineFitting(const std::vector<float>& data, const std::vector<bool>& mask, std::vector<int>& idxEdge, std::vector<float>& params, float& rms, std::vector<bool>& finalmask, float clipth, int clipn)
+{
+  int nClipped = 0;
+  return doCubicSplineFitting(data, mask, idxEdge.size()-1, true, idxEdge, params, rms, finalmask, nClipped, clipth, clipn);
+}
+
+std::vector<float> Scantable::doCubicSplineFitting(const std::vector<float>& data, const std::vector<bool>& mask, int nPiece, std::vector<int>& idxEdge, std::vector<float>& params, float& rms, std::vector<bool>& finalmask, float clipth, int clipn)
+{
+  int nClipped = 0;
+  return doCubicSplineFitting(data, mask, nPiece, false, idxEdge, params, rms, finalmask, nClipped, clipth, clipn);
+}
+
+std::vector<float> Scantable::doCubicSplineFitting(const std::vector<float>& data, const std::vector<bool>& mask, int nPiece, bool useGivenPieceBoundary, std::vector<int>& idxEdge, std::vector<float>& params, float& rms, std::vector<bool>& finalMask, int& nClipped, float thresClip, int nIterClip, bool getResidual)
 {
   if (data.size() != mask.size()) {
@@ -3344 +4070 @@
 
   int nChan = data.size();
+
+  finalMask.clear();
+  finalMask.resize(nChan);
+
   std::vector<int> maskArray(nChan);
   std::vector<int> x(nChan);
@@ -3353 +4083 @@
       j++;
     }
+    finalMask[i] = mask[i];
   }
   int initNData = j;
@@ -3362 +4093 @@
   int nElement = (int)(floor(floor((double)(initNData/nPiece))+0.5));
   std::vector<double> invEdge(nPiece-1);
-  idxEdge[0] = x[0];
+
+  if (useGivenPieceBoundary) {
+    if ((int)idxEdge.size() != nPiece+1) {
+      throw(AipsError("pieceEdge.size() must be equal to nPiece+1."));
+    }
+  } else {
+    idxEdge.clear();
+    idxEdge.resize(nPiece+1);
+    idxEdge[0] = x[0];
+  }
   for (int i = 1; i < nPiece; ++i) {
     int valX = x[nElement*i];
-    idxEdge[i] = valX;
+    if (!useGivenPieceBoundary) {
+      idxEdge[i] = valX;
+    }
     invEdge[i-1] = 1.0/(double)valX;
   }
-  idxEdge[nPiece] = x[initNData-1]+1;
+  if (!useGivenPieceBoundary) {
+    idxEdge[nPiece] = x[initNData-1]+1;
+  }
+
+  params.clear();
+  params.resize(nPiece*4);
 
   int nData = initNData;
@@ -3395 +4142 @@
     //           identity matrix (right).
     // the right part is used to calculate the inverse matrix of the left part. 
+
     double xMatrix[nDOF][2*nDOF];
     double zMatrix[nDOF];
@@ -3496 +4244 @@
       }
     }
+
     //compute a vector y which consists of the coefficients of the best-fit spline curves 
     //(a0,a1,a2,a3(,b3,c3,...)), namely, the ones for the leftmost piece and the ones of 
@@ -3545 +4294 @@
       }
     }
+
     if (idxEdge[nPiece] < nChan) {
       int n = idxEdge[nPiece]-1;
@@ -3562 +4312 @@
     }
 
+    double stdDev = 0.0;
+    for (int i = 0; i < nChan; ++i) {
+      stdDev += residual[i]*residual[i]*(double)maskArray[i];
+    }
+    stdDev = sqrt(stdDev/(double)nData);
+    rms = (float)stdDev;
+
     if ((nClip == nIterClip) || (thresClip <= 0.0)) {
       break;
     } else {
-      double stdDev = 0.0;
-      for (int i = 0; i < nChan; ++i) {
-        stdDev += residual[i]*residual[i]*(double)maskArray[i];
-      }
-      stdDev = sqrt(stdDev/(double)nData);
       
       double thres = stdDev * thresClip;
@@ -3576 +4328 @@
         if (abs(residual[i]) >= thres) {
           maskArray[i] = 0;
+          finalMask[i] = false;
         }
         if (maskArray[i] > 0) {
@@ -3586 +4339 @@
         nData = newNData;
       }
+
     }
   }
@@ -3605 +4359 @@
 }
 
-void Scantable::selectWaveNumbers(const int whichrow, const std::vector<bool>& chanMask, const bool applyFFT, const std::string& fftMethod, const std::string& fftThresh, const std::vector<int>& addNWaves, const std::vector<int>& rejectNWaves, std::vector<int>& nWaves)
-{
+void Scantable::selectWaveNumbers(const int whichrow, const std::vector<bool>& chanMask, const std::string& fftInfo, const std::vector<int>& addNWaves, const std::vector<int>& rejectNWaves, std::vector<int>& nWaves)
+//void Scantable::selectWaveNumbers(const int whichrow, const std::vector<bool>& chanMask, const bool applyFFT, const std::string& fftMethod, const std::string& fftThresh, const std::vector<int>& addNWaves, const std::vector<int>& rejectNWaves, std::vector<int>& nWaves)
+{
+  bool applyFFT;
+  std::string fftMethod;
+  std::string fftThresh;
+
   nWaves.clear();
 
+  parseFFTInfo(fftInfo, applyFFT, fftMethod, fftThresh);
   if (applyFFT) {
     string fftThAttr;
@@ -3618 +4378 @@
 
   addAuxWaveNumbers(whichrow, addNWaves, rejectNWaves, nWaves);
+}
+
+void Scantable::parseFFTInfo(const std::string& fftInfo, bool& applyFFT, std::string& fftMethod, std::string& fftThresh)
+{
+  istringstream iss(fftInfo);
+  std::string tmp;
+  std::vector<string> res;
+  while (getline(iss, tmp, ',')) {
+    res.push_back(tmp);
+  }
+  if (res.size() < 3) {
+    throw(AipsError("wrong value in 'fftinfo' parameter")) ;
+  }
+  applyFFT = (res[0] == "true");
+  fftMethod = res[1];
+  fftThresh = res[2];
 }
 
@@ -3702 +4478 @@
 {
   std::vector<int> tempAddNWaves, tempRejectNWaves;
+  tempAddNWaves.clear();
+  tempRejectNWaves.clear();
+
   for (uInt i = 0; i < addNWaves.size(); ++i) {
     tempAddNWaves.push_back(addNWaves[i]);
@@ -3745 +4524 @@
 void Scantable::setWaveNumberListUptoNyquistFreq(const int whichrow, std::vector<int>& nWaves)
 {
-  if ((nWaves.size() == 2)&&(nWaves[1] == -999)) {
-    int val = nWaves[0];
-    int nyquistFreq = nchan(getIF(whichrow))/2+1;
-    nWaves.clear();
-    if (val > nyquistFreq) {  // for safety, at least nWaves contains a constant; CAS-3759
-      nWaves.push_back(0);
-    }
-    while (val <= nyquistFreq) {
-      nWaves.push_back(val);
-      val++;
-    }
-  }
-}
-
-void Scantable::sinusoidBaseline(const std::vector<bool>& mask, const bool applyFFT, const std::string& fftMethod, const std::string& fftThresh, const std::vector<int>& addNWaves, const std::vector<int>& rejectNWaves, float thresClip, int nIterClip, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile)
+  int val = nWaves[0];
+  int nyquistFreq = nchan(getIF(whichrow))/2+1;
+  nWaves.clear();
+  if (val > nyquistFreq) {  // for safety, at least nWaves contains a constant; CAS-3759
+    nWaves.push_back(0);
+  }
+  while (val <= nyquistFreq) {
+    nWaves.push_back(val);
+    val++;
+  }
+}
+
+void Scantable::sinusoidBaseline(const std::vector<bool>& mask, const std::string& fftInfo, const std::vector<int>& addNWaves, const std::vector<int>& rejectNWaves, float thresClip, int nIterClip, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile, const std::string& bltable)
 {
   try {
@@ -3780 +4557 @@
     }
 
-    //Fitter fitter = Fitter();
-    //fitter.setExpression("sinusoid", nWaves);
-    //fitter.setIterClipping(thresClip, nIterClip);
+    bool showProgress;
+    int minNRow;
+    parseProgressInfo(progressInfo, showProgress, minNRow);
 
     int nRow = nrow();
     std::vector<bool> chanMask;
     std::vector<int> nWaves;
-
-    bool showProgress;
-    int minNRow;
-    parseProgressInfo(progressInfo, showProgress, minNRow);
+    std::vector<bool> finalChanMask;
+    float rms;
+
+    //---
+    bool outBaselintTable = (bltable != "");
+    STBaselineTable* bt = new STBaselineTable(*this);
+    ROScalarColumn<Double> *tcol = new ROScalarColumn<Double>(table_, "TIME");
+    Vector<Double> timeSecCol = tcol->getColumn();
+    //---
 
     for (int whichrow = 0; whichrow < nRow; ++whichrow) {
+      std::vector<float> sp = getSpectrum(whichrow);
       chanMask = getCompositeChanMask(whichrow, mask);
-      selectWaveNumbers(whichrow, chanMask, applyFFT, fftMethod, fftThresh, addNWaves, rejectNWaves, nWaves);
-
-      //FOR DEBUGGING------------
-      /*
-      if (whichrow < 0) {// == nRow -1) {
-        cout << "+++ i=" << setw(3) << whichrow << ", IF=" << setw(2) << getIF(whichrow);
-        if (applyFFT) {
-          cout << "[ ";
-          for (uInt j = 0; j < nWaves.size(); ++j) {
-            cout << nWaves[j] << ", ";
-          }
-          cout << " ]    " << endl;
-        }
-        cout << flush;
-      }
-      */
-      //-------------------------
-
-      //fitBaseline(chanMask, whichrow, fitter);
-      //setSpectrum((getResidual ? fitter.getResidual() : fitter.getFit()), whichrow);
+      selectWaveNumbers(whichrow, chanMask, fftInfo, addNWaves, rejectNWaves, nWaves);
+
       std::vector<float> params;
       int nClipped = 0;
-      std::vector<float> res = doSinusoidFitting(getSpectrum(whichrow), chanMask, nWaves, params, nClipped, thresClip, nIterClip, getResidual);
-      setSpectrum(res, whichrow);
-      //
+      std::vector<float> res = doSinusoidFitting(sp, chanMask, nWaves, params, rms, finalChanMask, nClipped, thresClip, nIterClip, getResidual);
+
+      //---
+      if (outBaselintTable) {
+        uInt nparam = nWaves.size();
+        Vector<Int> fparam(nparam);
+        for (uInt i = 0; i < nparam; ++i) {
+          fparam[i] = nWaves[i];
+        }
+        std::vector<int> finalMaskList0;
+        finalMaskList0.clear();
+        for (uInt i = 0; i < finalChanMask.size(); ++i) {
+          if (finalChanMask[i]) {
+            if ((i == 0)||(i == finalChanMask.size()-1)) {
+              finalMaskList0.push_back(i);
+            } else {
+              if ((finalChanMask[i])&&(!finalChanMask[i-1])) {
+                finalMaskList0.push_back(i);
+              }
+              if ((finalChanMask[i])&&(!finalChanMask[i+1])) {
+                finalMaskList0.push_back(i);
+              }
+            }
+          }
+        }
+        Vector<uInt> finalMaskList(finalMaskList0.size());
+        for (uInt i = 0; i < finalMaskList0.size(); ++i) {
+          finalMaskList[i] = (uInt)finalMaskList0[i];
+        }
+
+        bt->appenddata(uInt(getScan(whichrow)), uInt(getCycle(whichrow)), uInt(getBeam(whichrow)), uInt(getIF(whichrow)), uInt(getPol(whichrow)), 
+                       uInt(0), 
+                       timeSecCol[whichrow],
+                       Bool(true), 
+                       STBaselineFunc::Sinusoid, 
+                       fparam, 
+                       Vector<Float>(),
+                       finalMaskList, 
+                       Vector<Float>(params), 
+                       Float(rms), 
+                       uInt(sp.size()), 
+                       Float(thresClip), 
+                       uInt(nIterClip), 
+                       Float(0.0),
+                       uInt(0),
+                       Vector<uInt>());
+      } else {
+        setSpectrum(res, whichrow);
+      }
+      //---
 
       outputFittingResult(outLogger, outTextFile, csvFormat, chanMask, whichrow, coordInfo, hasSameNchan, ofs, "sinusoidBaseline()", params, nClipped);
@@ -3824 +4636 @@
     }
 
+    //---
+    if (outBaselintTable) {
+      bt->save(bltable);
+    }
+    //---
+    delete bt;
+
     if (outTextFile) ofs.close();
 
@@ -3831 +4650 @@
 }
 
-void Scantable::autoSinusoidBaseline(const std::vector<bool>& mask, const bool applyFFT, const std::string& fftMethod, const std::string& fftThresh, const std::vector<int>& addNWaves, const std::vector<int>& rejectNWaves, float thresClip, int nIterClip, const std::vector<int>& edge, float threshold, int chanAvgLimit, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile)
+void Scantable::autoSinusoidBaseline(const std::vector<bool>& mask, const std::string& fftInfo, const std::vector<int>& addNWaves, const std::vector<int>& rejectNWaves, float thresClip, int nIterClip, const std::vector<int>& edge, float threshold, int chanAvgLimit, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile, const std::string& bltable)
+//void Scantable::autoSinusoidBaseline(const std::vector<bool>& mask, const bool applyFFT, const std::string& fftMethod, const std::string& fftThresh, const std::vector<int>& addNWaves, const std::vector<int>& rejectNWaves, float thresClip, int nIterClip, const std::vector<int>& edge, float threshold, int chanAvgLimit, bool getResidual, const std::string& progressInfo, const bool outLogger, const std::string& blfile, const std::string& bltable)
 {
   try {
@@ -3852 +4672 @@
     }
 
-    //Fitter fitter = Fitter();
-    //fitter.setExpression("sinusoid", nWaves);
-    //fitter.setIterClipping(thresClip, nIterClip);
+    bool showProgress;
+    int minNRow;
+    parseProgressInfo(progressInfo, showProgress, minNRow);
+
+    int minEdgeSize = getIFNos().size()*2;
+    STLineFinder lineFinder = STLineFinder();
+    lineFinder.setOptions(threshold, 3, chanAvgLimit);
 
     int nRow = nrow();
     std::vector<bool> chanMask;
     std::vector<int> nWaves;
-
-    int minEdgeSize = getIFNos().size()*2;
-    STLineFinder lineFinder = STLineFinder();
-    lineFinder.setOptions(threshold, 3, chanAvgLimit);
-
-    bool showProgress;
-    int minNRow;
-    parseProgressInfo(progressInfo, showProgress, minNRow);
+    std::vector<bool> finalChanMask;
+    float rms;
+
+    //---
+    bool outBaselintTable = (bltable != "");
+    STBaselineTable* bt = new STBaselineTable(*this);
+    ROScalarColumn<Double> *tcol = new ROScalarColumn<Double>(table_, "TIME");
+    Vector<Double> timeSecCol = tcol->getColumn();
+    //---
 
     for (int whichrow = 0; whichrow < nRow; ++whichrow) {
-
-      //-------------------------------------------------------
-      //chanMask = getCompositeChanMask(whichrow, mask, edge, minEdgeSize, lineFinder);
-      //-------------------------------------------------------
+      std::vector<float> sp = getSpectrum(whichrow);
+      //-- composote given channel mask and flagtra --------
       int edgeSize = edge.size();
       std::vector<int> currentEdge;
+      currentEdge.clear();
       if (edgeSize >= 2) {
         int idx = 0;
@@ -3888 +4712 @@
         throw(AipsError("Wrong length of edge element"));
       }
-      lineFinder.setData(getSpectrum(whichrow));
+      lineFinder.setData(sp);
       lineFinder.findLines(getCompositeChanMask(whichrow, mask), currentEdge, whichrow);
       chanMask = lineFinder.getMask();
-      //-------------------------------------------------------
-
-      selectWaveNumbers(whichrow, chanMask, applyFFT, fftMethod, fftThresh, addNWaves, rejectNWaves, nWaves);
-
-      //fitBaseline(chanMask, whichrow, fitter);
-      //setSpectrum((getResidual ? fitter.getResidual() : fitter.getFit()), whichrow);
+      //-- composote given channel mask and flagtra END --------
+      selectWaveNumbers(whichrow, chanMask, fftInfo, addNWaves, rejectNWaves, nWaves);
+
       std::vector<float> params;
       int nClipped = 0;
-      std::vector<float> res = doSinusoidFitting(getSpectrum(whichrow), chanMask, nWaves, params, nClipped, thresClip, nIterClip, getResidual);
-      setSpectrum(res, whichrow);
-      //
+      std::vector<float> res = doSinusoidFitting(sp, chanMask, nWaves, params, rms, finalChanMask, nClipped, thresClip, nIterClip, getResidual);
+
+      //---
+      if (outBaselintTable) {
+        uInt nparam = nWaves.size();
+        Vector<Int> fparam(nparam);
+        for (uInt i = 0; i < nparam; ++i) {
+          fparam[i] = nWaves[i];
+        }
+        std::vector<int> finalMaskList0;
+        finalMaskList0.clear();
+        for (uInt i = 0; i < finalChanMask.size(); ++i) {
+          if (finalChanMask[i]) {
+            if ((i == 0)||(i == finalChanMask.size()-1)) {
+              finalMaskList0.push_back(i);
+            } else {
+              if ((finalChanMask[i])&&(!finalChanMask[i-1])) {
+                finalMaskList0.push_back(i);
+              }
+              if ((finalChanMask[i])&&(!finalChanMask[i+1])) {
+                finalMaskList0.push_back(i);
+              }
+            }
+          }
+        }
+        Vector<uInt> finalMaskList(finalMaskList0.size());
+        for (uInt i = 0; i < finalMaskList0.size(); ++i) {
+          finalMaskList[i] = (uInt)finalMaskList0[i];
+        }
+
+        Vector<uInt> cEdge(currentEdge.size());
+        for (uInt i = 0; i < currentEdge.size(); ++i) {
+          cEdge[i] = currentEdge[i];
+        }
+
+        bt->appenddata(uInt(getScan(whichrow)), uInt(getCycle(whichrow)), uInt(getBeam(whichrow)), uInt(getIF(whichrow)), uInt(getPol(whichrow)), 
+                       uInt(0), 
+                       timeSecCol[whichrow],
+                       Bool(true), 
+                       STBaselineFunc::Sinusoid, 
+                       fparam, 
+                       Vector<Float>(),
+                       finalMaskList, 
+                       Vector<Float>(params), 
+                       Float(rms), 
+                       uInt(sp.size()), 
+                       Float(thresClip), 
+                       uInt(nIterClip), 
+                       Float(threshold),
+                       uInt(chanAvgLimit),
+                       cEdge);
+      } else {
+        setSpectrum(res, whichrow);
+      }
+      //---
 
       outputFittingResult(outLogger, outTextFile, csvFormat, chanMask, whichrow, coordInfo, hasSameNchan, ofs, "autoSinusoidBaseline()", params, nClipped);
@@ -3907 +4780 @@
     }
 
+    //---
+    if (outBaselintTable) {
+      bt->save(bltable);
+    }
+    //---
+    delete bt;
+
     if (outTextFile) ofs.close();
 
@@ -3914 +4794 @@
 }
 
-std::vector<float> Scantable::doSinusoidFitting(const std::vector<float>& data, const std::vector<bool>& mask, const std::vector<int>& waveNumbers, std::vector<float>& params, int& nClipped, float thresClip, int nIterClip, bool getResidual)
+std::vector<float> Scantable::doSinusoidFitting(const std::vector<float>& data, const std::vector<bool>& mask, const std::vector<int>& waveNumbers, std::vector<float>& params, float& rms, std::vector<bool>& finalmask, float clipth, int clipn)
+{
+  int nClipped = 0;
+  return doSinusoidFitting(data, mask, waveNumbers, params, rms, finalmask, nClipped, clipth, clipn);
+}
+
+std::vector<float> Scantable::doSinusoidFitting(const std::vector<float>& data, const std::vector<bool>& mask, const std::vector<int>& waveNumbers, std::vector<float>& params, float& rms, std::vector<bool>& finalMask, int& nClipped, float thresClip, int nIterClip, bool getResidual)
 {
   if (data.size() != mask.size()) {
@@ -3939 +4825 @@
 
   int nChan = data.size();
+
+  finalMask.clear();
+  finalMask.resize(nChan);
+
   std::vector<int> maskArray;
   std::vector<int> x;
@@ -3946 +4836 @@
       x.push_back(i);
     }
+    finalMask[i] = mask[i];
   }
 
@@ -4086 +4977 @@
     }
 
+    double stdDev = 0.0;
+    for (int i = 0; i < nChan; ++i) {
+      stdDev += residual[i]*residual[i]*(double)maskArray[i];
+    }
+    stdDev = sqrt(stdDev/(double)nData);
+    rms = (float)stdDev;
+
     if ((nClip == nIterClip) || (thresClip <= 0.0)) {
       break;
     } else {
-      double stdDev = 0.0;
-      for (int i = 0; i < nChan; ++i) {
-        stdDev += residual[i]*residual[i]*(double)maskArray[i];
-      }
-      stdDev = sqrt(stdDev/(double)nData);
-      
+
       double thres = stdDev * thresClip;
       int newNData = 0;
@@ -4100 +4993 @@
         if (abs(residual[i]) >= thres) {
           maskArray[i] = 0;
+          finalMask[i] = false;
         }
         if (maskArray[i] > 0) {
@@ -4110 +5004 @@
         nData = newNData;
       }
+
     }
   }

trunk/src/Scantable.h

@@ -28 +28 @@
 #include <casa/Quanta/Quantum.h>
 #include <casa/Utilities/CountedPtr.h>
-
 #include <coordinates/Coordinates/SpectralCoordinate.h>
-
 #include <measures/TableMeasures/ScalarMeasColumn.h>
-
 #include <scimath/Mathematics/FFTServer.h>
-
 #include <tables/Tables/ArrayColumn.h>
 #include <tables/Tables/ScalarColumn.h>
 #include <tables/Tables/Table.h>
 
-
 #include "MathUtils.h"
+#include "STBaselineEnum.h"
 #include "STFit.h"
 #include "STFitEntry.h"
@@ -507 +503 @@
   void regridChannel( int nchan, double dnu, int irow ) ;
   void regridChannel( int nchan, double dnu, double fmin, int irow ) ;
-
   void regridSpecChannel( double dnu, int nchan=-1 ) ;
 
   bool getFlagtraFast(casa::uInt whichrow);
 
-  void polyBaseline(const std::vector<bool>& mask, 
-                    int order, 
+  std::vector<std::string> applyBaselineTable(const std::string& bltable, const std::string& outbltable, const bool outbltableexists, const bool overwrite);
+  std::vector<std::string> subBaseline(const std::vector<std::string>& blInfoList, const std::string& outbltable, const bool outbltableexists, const bool overwrite);
+  void polyBaseline(const std::vector<bool>& mask,
+                    int order,
+                    float thresClip, 
+                    int nIterClip,
                     bool getResidual=true,
                     const std::string& progressInfo="true,1000", 
-                    const bool outLogger=false, 
-                    const std::string& blfile="");
+                    const bool outLogger=false,
+                    const std::string& blfile="",
+                    const std::string& bltable="");
   void autoPolyBaseline(const std::vector<bool>& mask,
-                        int order, 
-                        const std::vector<int>& edge, 
-                        float threshold=3.0, 
-                        int chanAvgLimit=1, 
-                        bool getResidual=true,
-                        const std::string& progressInfo="true,1000", 
-                        const bool outLogger=false, 
-                        const std::string& blfile="");
+                        int order,
+                        float thresClip, 
+                        int nIterClip,
+                        const std::vector<int>& edge, 
+                        float threshold=3.0, 
+                        int chanAvgLimit=1, 
+                        bool getResidual=true,
+                        const std::string& progressInfo="true,1000", 
+                        const bool outLogger=false, 
+                        const std::string& blfile="",
+                        const std::string& bltable="");
   void chebyshevBaseline(const std::vector<bool>& mask,
                          int order,
@@ -534 +537 @@
                          const std::string& progressInfo="true,1000", 
                          const bool outLogger=false,
-                         const std::string& blfile="");
+                         const std::string& blfile="",
+                         const std::string& bltable="");
   void autoChebyshevBaseline(const std::vector<bool>& mask,
                              int order,
@@ -545 +549 @@
                              const std::string& progressInfo="true,1000", 
                              const bool outLogger=false, 
-                             const std::string& blfile="");
+                             const std::string& blfile="",
+                             const std::string& bltable="");
   void cubicSplineBaseline(const std::vector<bool>& mask,
                            int nPiece,
@@ -553 +558 @@
                            const std::string& progressInfo="true,1000", 
                            const bool outLogger=false,
-                           const std::string& blfile="");
+                           const std::string& blfile="",
+                           const std::string& bltable="");
   void autoCubicSplineBaseline(const std::vector<bool>& mask,
                                int nPiece,
@@ -564 +570 @@
                                const std::string& progressInfo="true,1000", 
                                const bool outLogger=false, 
-                               const std::string& blfile="");
+                               const std::string& blfile="",
+                               const std::string& bltable="");
   void sinusoidBaseline(const std::vector<bool>& mask,
-                        const bool applyFFT, 
-                        const std::string& fftMethod, 
-                        const std::string& fftThresh, 
+                        const std::string& fftInfo, 
                         const std::vector<int>& addNWaves, 
                         const std::vector<int>& rejectNWaves, 
@@ -576 +581 @@
                         const std::string& progressInfo="true,1000", 
                         const bool outLogger=false,
-                        const std::string& blfile="");
+                        const std::string& blfile="",
+                        const std::string& bltable="");
   void autoSinusoidBaseline(const std::vector<bool>& mask,
-                            const bool applyFFT, 
-                            const std::string& fftMethod, 
-                            const std::string& fftThresh, 
+                            const std::string& fftInfo, 
                             const std::vector<int>& addNWaves, 
                             const std::vector<int>& rejectNWaves, 
@@ -591 +595 @@
                             const std::string& progressInfo="true,1000", 
                             const bool outLogger=false, 
-                            const std::string& blfile="");
+                            const std::string& blfile="",
+                            const std::string& bltable="");
   std::vector<float> execFFT(const int whichrow, 
                              const std::vector<bool>& inMask,
@@ -628 +633 @@
                                          float threshold,
                                          int chanAvgLimit);
+  static std::vector<bool> getMaskFromMaskList(const int nchan,
+                                               const std::vector<int>& masklist);
+  static std::vector<int> splitToIntList(const std::string& str, const char delim);
+  static std::vector<string> splitToStringList(const std::string& str, const char delim);
+
 
 
@@ -743 +753 @@
 
   void fitBaseline(const std::vector<bool>& mask, int whichrow, Fitter& fitter);
+  double getNormalPolynomial(int n, double x);
   double getChebyshevPolynomial(int n, double x);
+  std::vector<float> doPolynomialFitting(const std::vector<float>& data, 
+                                         const std::vector<bool>& mask,
+                                         int order,
+                                         std::vector<float>& params,
+                                         float& rms, 
+                                         std::vector<bool>& finalMask, 
+                                         float clipth, 
+                                         int clipn);
+  std::vector<float> doPolynomialFitting(const std::vector<float>& data, 
+                                         const std::vector<bool>& mask,
+                                         int order,
+                                         std::vector<float>& params,
+                                         float& rms, 
+                                         std::vector<bool>& finalMask, 
+                                         int& nClipped,
+                                         float thresClip=3.0, 
+                                         int nIterClip=0,
+                                         bool getResidual=true);
   std::vector<float> doChebyshevFitting(const std::vector<float>& data, 
+                                        const std::vector<bool>& mask,
+                                        int order,
+                                        std::vector<float>& params,
+                                        float& rms, 
+                                        std::vector<bool>& finalMask, 
+                                        float clipth, 
+                                        int clipn);
+  std::vector<float> doChebyshevFitting(const std::vector<float>& data, 
+                                        const std::vector<bool>& mask,
+                                        int order,
+                                        std::vector<float>& params,
+                                        float& rms, 
+                                        std::vector<bool>& finalMask, 
+                                        int& nClipped,
+                                        float thresClip=3.0, 
+                                        int nIterClip=0,
+                                        bool getResidual=true);
+  std::vector<float> doLeastSquareFitting(const std::vector<float>& data, 
+                                          const std::vector<bool>& mask, 
+                                          double (Scantable::*pfunc)(int, double), 
+                                          int order, 
+                                          std::vector<float>& params, 
+                                          float& rms, 
+                                          std::vector<bool>& finalMask, 
+                                          int& nClipped, 
+                                          float thresClip=3.0, 
+                                          int nIterClip=0, 
+                                          bool getResidual=true);
+  std::vector<float> doCubicSplineFitting(const std::vector<float>& data, 
                                           const std::vector<bool>& mask,
-                                          int order,
+                                          std::vector<int>& idxEdge,
                                           std::vector<float>& params,
+                                          float& rms, 
                                           std::vector<bool>& finalMask, 
-                                          float& rms, 
-                                          int& nClipped,
-                                          float thresClip=3.0, 
-                                          int nIterClip=1,
-                                          bool getResidual=true);
+                                          float clipth, 
+                                          int clipn);
   std::vector<float> doCubicSplineFitting(const std::vector<float>& data, 
                                           const std::vector<bool>& mask,
@@ -759 +815 @@
                                           std::vector<int>& idxEdge,
                                           std::vector<float>& params,
+                                          float& rms, 
+                                          std::vector<bool>& finalMask, 
+                                          float clipth, 
+                                          int clipn);
+  std::vector<float> doCubicSplineFitting(const std::vector<float>& data, 
+                                          const std::vector<bool>& mask,
+                                          int nPiece,
+                                          bool useGivenPieceBoundary, 
+                                          std::vector<int>& idxEdge,
+                                          std::vector<float>& params,
+                                          float& rms, 
+                                          std::vector<bool>& finalMask, 
                                           int& nClipped,
                                           float thresClip=3.0, 
-                                          int nIterClip=1,
+                                          int nIterClip=0,
                                           bool getResidual=true);
   std::vector<float> doSinusoidFitting(const std::vector<float>& data, 
@@ -767 +835 @@
                                        const std::vector<int>& waveNumbers,
                                        std::vector<float>& params,
+                                       float& rms, 
+                                       std::vector<bool>& finalMask, 
+                                       float clipth, 
+                                       int clipn);
+  std::vector<float> doSinusoidFitting(const std::vector<float>& data, 
+                                       const std::vector<bool>& mask,
+                                       const std::vector<int>& waveNumbers,
+                                       std::vector<float>& params,
+                                       float& rms, 
+                                       std::vector<bool>& finalMask, 
                                        int& nClipped,
                                        float thresClip=3.0, 
-                                       int nIterClip=1,
+                                       int nIterClip=0,
                                        bool getResidual=true);
   void selectWaveNumbers(const int whichrow, 
                          const std::vector<bool>& chanMask, 
-                         const bool applyFFT, 
-                         const std::string& fftMethod, 
-                         const std::string& fftThresh, 
+                         const std::string& fftInfo, 
+                         //const bool applyFFT, 
+                         //const std::string& fftMethod, 
+                         //const std::string& fftThresh, 
                          const std::vector<int>& addNWaves, 
                          const std::vector<int>& rejectNWaves, 
                          std::vector<int>& nWaves);
+  void parseFFTInfo(const std::string& fftInfo, 
+                    bool& applyFFT, 
+                    std::string& fftMethod, 
+                    std::string& fftThresh);
   void parseThresholdExpression(const std::string& fftThresh,
                                 std::string& fftThAttr,
@@ -821 +904 @@
                                            int order);
   double doGetRms(const std::vector<bool>& mask, const casa::Vector<casa::Float>& spec);
+  std::string packFittingResults(const int irow, const std::vector<float>& params, const float rms);
+  void parseBlInfo(const std::string& blInfo, int& whichrow, STBaselineFunc::FuncName& ftype, std::vector<int>& fpar, std::vector<bool>& mask, float& thresClip, int& nIterClip, bool& useLineFinder, float& thresLF, std::vector<int>& edgeLF, int& avgLF);
+ std::vector<float> doApplyBaselineTable(std::vector<float>& spec, std::vector<bool>& mask, const STBaselineFunc::FuncName ftype, std::vector<int>& fpar, std::vector<float>& params, float&rms);
+ std::vector<float> doSubtractBaseline(std::vector<float>& spec, std::vector<bool>& mask, const STBaselineFunc::FuncName ftype, std::vector<int>& fpar, std::vector<float>& params, float&rms, std::vector<bool>& finalmask, float clipth, int clipn, bool uself, int irow, float lfth, std::vector<int>& lfedge, int lfavg);
 
 };
-
 } // namespace
 

trunk/src/ScantableWrapper.h

@@ -278 +278 @@
   { table_->regridSpecChannel( dnu, nchan ); }
 
-  void polyBaseline(const std::vector<bool>& mask, int order, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="")
-  { table_->polyBaseline(mask, order, getresidual, showprogress, outlog, blfile); }
-
-  void autoPolyBaseline(const std::vector<bool>& mask, int order, const std::vector<int>& edge, float threshold=5.0, int chan_avg_limit=1, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="")
-  { table_->autoPolyBaseline(mask, order, edge, threshold, chan_avg_limit, getresidual, showprogress, outlog, blfile); }
-
-  void chebyshevBaseline(const std::vector<bool>& mask, int order, float clipthresh, int clipniter, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="")
-  { table_->chebyshevBaseline(mask, order, clipthresh, clipniter, getresidual, showprogress, outlog, blfile); }
-
-  void autoChebyshevBaseline(const std::vector<bool>& mask, int order, float clipthresh, int clipniter, const std::vector<int>& edge, float threshold=5.0, int chan_avg_limit=1, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="")
-  { table_->autoChebyshevBaseline(mask, order, clipthresh, clipniter, edge, threshold, chan_avg_limit, getresidual, showprogress, outlog, blfile); }
-
-  void cubicSplineBaseline(const std::vector<bool>& mask, int npiece, float clipthresh, int clipniter, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="")
-  { table_->cubicSplineBaseline(mask, npiece, clipthresh, clipniter, getresidual, showprogress, outlog, blfile); }
-
-  void autoCubicSplineBaseline(const std::vector<bool>& mask, int npiece, float clipthresh, int clipniter, const std::vector<int>& edge, float threshold=5.0, int chan_avg_limit=1, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="")
-  { table_->autoCubicSplineBaseline(mask, npiece, clipthresh, clipniter, edge, threshold, chan_avg_limit, getresidual, showprogress, outlog, blfile); }
-
-  void sinusoidBaseline(const std::vector<bool>& mask, const bool applyfft, const std::string& fftmethod, const std::string& fftthresh, const std::vector<int>& addwn, const std::vector<int>& rejwn, float clipthresh, int clipniter, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="")
-  { table_->sinusoidBaseline(mask, applyfft, fftmethod, fftthresh, addwn, rejwn, clipthresh, clipniter, getresidual, showprogress, outlog, blfile); }
-
-  void autoSinusoidBaseline(const std::vector<bool>& mask, const bool applyfft, const std::string& fftmethod, const std::string& fftthresh, const std::vector<int>& addwn, const std::vector<int>& rejwn, float clipthresh, int clipniter, const std::vector<int>& edge, float threshold=5.0, int chan_avg_limit=1, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="")
-  { table_->autoSinusoidBaseline(mask, applyfft, fftmethod, fftthresh, addwn, rejwn, clipthresh, clipniter, edge, threshold, chan_avg_limit, getresidual, showprogress, outlog, blfile); }
+  std::vector<std::string> applyBaselineTable(const std::string& bltable, const std::string& outbltable, const bool outbltableexists, const bool overwrite)
+  { return table_->applyBaselineTable(bltable, outbltable, outbltableexists, overwrite); }
+  std::vector<std::string> subBaseline(const std::vector<std::string>& blinfo, const std::string& outbltable, const bool outbltableexists, const bool overwrite)
+  { return table_->subBaseline(blinfo, outbltable, outbltableexists, overwrite); }
+  void polyBaseline(const std::vector<bool>& mask, int order, float clipthresh, int clipniter, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="", const std::string& bltable="")
+  { table_->polyBaseline(mask, order, clipthresh, clipniter, getresidual, showprogress, outlog, blfile, bltable); }
+
+  void autoPolyBaseline(const std::vector<bool>& mask, int order, float clipthresh, int clipniter, const std::vector<int>& edge, float threshold=5.0, int chan_avg_limit=1, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="", const std::string& bltable="")
+  { table_->autoPolyBaseline(mask, order, clipthresh, clipniter, edge, threshold, chan_avg_limit, getresidual, showprogress, outlog, blfile, bltable); }
+
+  void chebyshevBaseline(const std::vector<bool>& mask, int order, float clipthresh, int clipniter, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="", const std::string& bltable="")
+  { table_->chebyshevBaseline(mask, order, clipthresh, clipniter, getresidual, showprogress, outlog, blfile, bltable); }
+
+  void autoChebyshevBaseline(const std::vector<bool>& mask, int order, float clipthresh, int clipniter, const std::vector<int>& edge, float threshold=5.0, int chan_avg_limit=1, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="", const std::string& bltable="")
+  { table_->autoChebyshevBaseline(mask, order, clipthresh, clipniter, edge, threshold, chan_avg_limit, getresidual, showprogress, outlog, blfile, bltable); }
+
+  void cubicSplineBaseline(const std::vector<bool>& mask, int npiece, float clipthresh, int clipniter, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="", const std::string& bltable="")
+  { table_->cubicSplineBaseline(mask, npiece, clipthresh, clipniter, getresidual, showprogress, outlog, blfile, bltable); }
+
+  void autoCubicSplineBaseline(const std::vector<bool>& mask, int npiece, float clipthresh, int clipniter, const std::vector<int>& edge, float threshold=5.0, int chan_avg_limit=1, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="", const std::string& bltable="")
+  { table_->autoCubicSplineBaseline(mask, npiece, clipthresh, clipniter, edge, threshold, chan_avg_limit, getresidual, showprogress, outlog, blfile, bltable); }
+
+  void sinusoidBaseline(const std::vector<bool>& mask, const std::string& fftinfo, const std::vector<int>& addwn, const std::vector<int>& rejwn, float clipthresh, int clipniter, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="", const std::string& bltable="")
+  { table_->sinusoidBaseline(mask, fftinfo, addwn, rejwn, clipthresh, clipniter, getresidual, showprogress, outlog, blfile, bltable); }
+
+  void autoSinusoidBaseline(const std::vector<bool>& mask, const std::string& fftinfo, const std::vector<int>& addwn, const std::vector<int>& rejwn, float clipthresh, int clipniter, const std::vector<int>& edge, float threshold=5.0, int chan_avg_limit=1, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="", const std::string& bltable="")
+  { table_->autoSinusoidBaseline(mask, fftinfo, addwn, rejwn, clipthresh, clipniter, edge, threshold, chan_avg_limit, getresidual, showprogress, outlog, blfile, bltable); }
 
   float getRms(const std::vector<bool>& mask, int whichrow)

trunk/src/python_Scantable.cpp

@@ -145 +145 @@
     .def("_regrid_specchan", &ScantableWrapper::regridSpecChannel, 
          (boost::python::arg("nchan")=-1) )
+    .def("_apply_bltable", &ScantableWrapper::applyBaselineTable)
+    .def("_sub_baseline", &ScantableWrapper::subBaseline)
     .def("_poly_baseline", &ScantableWrapper::polyBaseline)
     .def("_auto_poly_baseline", &ScantableWrapper::autoPolyBaseline)