Changeset 2767 for trunk/src

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/src

Files:

• STBaselineEnum.h (modified) (1 diff)
• STBaselineTable.cpp (modified) (6 diffs)
• STBaselineTable.h (modified) (1 diff)
• Scantable.cpp (modified) (54 diffs)
• Scantable.h (modified) (13 diffs)
• ScantableWrapper.h (modified) (1 diff)
• python_Scantable.cpp (modified) (1 diff)

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)