Changeset 1931

Timestamp:

09/17/10 18:00:47 (14 years ago)

Author:

WataruKawasaki

Message:

New Development: No

JIRA Issue:

Ready for Test: Yes

Interface Changes: No

What Interface Changed:

Test Programs:

Put in Release Notes: No

Module(s): sdbaseline

Description: a new version of poly_baseline() by Malte

Location:

trunk

Files:

• python/scantable.py (modified) (17 diffs)
• src/Scantable.cpp (modified) (5 diffs)
• src/Scantable.h (modified) (2 diffs)
• src/ScantableWrapper.h (modified) (2 diffs)

trunk/python/scantable.py

@@ -337 +337 @@
         Parameters:
 
-            filename:    the name of a file to write the output to
+            filename:    the name of a file to write the putput to
                          Default - no file output
 
@@ -377 +377 @@
 
     def set_spectrum(self, spec, rowno):
-        """Set the spectrum for the current row in the scantable.
+        """Return the spectrum for the current row in the scantable as a list.
 
         Parameters:
@@ -738 +738 @@
         """\
         Get a list of time stamps for the observations.
-        Return a datetime object or a string (default) for each
-        integration time stamp in the scantable.
+        Return a datetime object for each integration time stamp in the scantable.
 
         Parameters:
@@ -1159 +1158 @@
         return msk
 
-    def get_masklist(self, mask=None, row=0):
+    def get_masklist(self, mask=None, row=0, silent=False):
         """\
         Compute and return a list of mask windows, [min, max].
@@ -1193 +1192 @@
         if not i:
             msg += "\nThis mask is only valid for IF=%d" % (self.getif(i))
-        asaplog.push(msg)
+        if not silent:
+            asaplog.push(msg)
         masklist=[]
         ist, ien = None, None
@@ -1284 +1284 @@
         """\
         Set or replace the restfrequency specified and
-        if the 'freqs' argument holds a scalar,
+        If the 'freqs' argument holds a scalar,
         then that rest frequency will be applied to all the selected
         data.  If the 'freqs' argument holds
@@ -1434 +1434 @@
                 out += "Function: %s\n  Parameters:" % (func)
                 for i in items:
-                    if i == '':
-                        continue
                     s = i.split("=")
                     out += "\n   %s = %s" % (s[0], s[1])
@@ -1937 +1935 @@
                 workscan._setspectrum(f.fitter.getresidual(), r)
                 self.blpars.append(f.get_parameters())
-                self.masklists.append(workscan.get_masklist(f.mask, row=r))
+                self.masklists.append(workscan.get_masklist(f.mask, row=r, silent=True))
                 self.actualmask.append(f.mask)
 
@@ -1952 +1950 @@
             raise RuntimeError(msg)
 
-
+    @asaplog_post_dec
     def poly_baseline(self, mask=None, order=0, plot=False, batch=False, insitu=None, rows=None):
         """\
@@ -1968 +1966 @@
                         Otherwise, the scaling is done in-situ
                         The default is taken from .asaprc (False)
-            rows:       row numbers of spectra to be processed.
+            rows:       row numbers of spectra to be baselined.
                         (default is None: for all rows)
         Example:
@@ -1975 +1973 @@
             bscan = scan.poly_baseline(order=3)
         """
+        
+        varlist = vars()
+        
         if insitu is None: insitu = rcParams["insitu"]
         if insitu:
@@ -1981 +1982 @@
             workscan = self.copy()
 
-        varlist = vars()
         nchan = workscan.nchan()
         
@@ -1994 +1994 @@
             
             if len(rows) > 0:
-                self.blpars = []
-                self.masklists = []
-                self.actualmask = []
+                workscan.blpars = []
+                workscan.masklists = []
+                workscan.actualmask = []
 
             if batch:
-                for r in rows:
-                    workscan._poly_baseline_batch(mask, order, r)
+                workscan._poly_baseline_batch(mask, order)
             elif plot:
                 f = fitter()
@@ -2019 +2018 @@
                         continue
                     workscan._setspectrum(f.fitter.getresidual(), r)
-                    self.blpars.append(f.get_parameters())
-                    self.masklists.append(workscan.get_masklist(f.mask, row=r))
-                    self.actualmask.append(f.mask)
+                    workscan.blpars.append(f.get_parameters())
+                    workscan.masklists.append(workscan.get_masklist(f.mask, row=r))
+                    workscan.actualmask.append(f.mask)
                     
                 f._p.unmap()
                 f._p = None
             else:
-                import array
                 for r in rows:
-                    pars = array.array("f", [0.0 for i in range(order+1)])
-                    pars_adr = pars.buffer_info()[0]
-                    pars_len = pars.buffer_info()[1]
+                    fitparams = workscan._poly_baseline(mask, order, r)
+                    params = fitparams.getparameters()
+                    fmtd = ", ".join(["p%d = %3.6f" % (i, v) for i, v in enumerate(params)])
+                    errors = fitparams.geterrors()
+                    fmask = mask_and(mask, workscan._getmask(r))
+
+                    workscan.blpars.append({"params":params,
+                                            "fixed": fitparams.getfixedparameters(),
+                                            "formatted":fmtd, "errors":errors})
+                    workscan.masklists.append(workscan.get_masklist(fmask, r, silent=True))
+                    workscan.actualmask.append(fmask)
                     
-                    errs = array.array("f", [0.0 for i in range(order+1)])
-                    errs_adr = errs.buffer_info()[0]
-                    errs_len = errs.buffer_info()[1]
-                    
-                    fmsk = array.array("i", [1 for i in range(nchan)])
-                    fmsk_adr = fmsk.buffer_info()[0]
-                    fmsk_len = fmsk.buffer_info()[1]
-                    
-                    workscan._poly_baseline(mask, order, r, pars_adr, pars_len, errs_adr, errs_len, fmsk_adr, fmsk_len)
-                    
-                    params = pars.tolist()
-                    fmtd = ""
-                    for i in xrange(len(params)): fmtd += "  p%d= %3.6f," % (i, params[i])
-                    fmtd = fmtd[:-1]  # remove trailing ","
-                    errors = errs.tolist()
-                    fmask = fmsk.tolist()
-                    for i in xrange(len(fmask)): fmask[i] = (fmask[i] > 0)    # transform (1/0) -> (True/False)
-                    
-                    self.blpars.append({"params":params, "fixed":[], "formatted":fmtd, "errors":errors})
-                    self.masklists.append(workscan.get_masklist(fmask, r))
-                    self.actualmask.append(fmask)
-                    
-                    asaplog.push(str(fmtd))
+                    asaplog.push(fmtd)
             
             workscan._add_history("poly_baseline", varlist)
@@ -2077 +2061 @@
                            insitu=None, rows=None):
         """\
-        Return a scan which has been baselined (all rows by default)
-        by a polynomial.
+        Return a scan which has been baselined (all rows) by a polynomial.
         Spectral lines are detected first using linefinder and masked out
         to avoid them affecting the baseline solution.
@@ -2206 +2189 @@
 
             # Show mask list
-            masklist=workscan.get_masklist(f.mask, row=r)
+            masklist=workscan.get_masklist(f.mask, row=r, silent=True)
             msg = "mask range: "+str(masklist)
             asaplog.push(msg, False)
@@ -2323 +2306 @@
         """\
 
-        Return a scan where all spectra are scaled by the given 'factor'
+        Return a scan where all spectra are scaled by the give 'factor'
 
         Parameters:

trunk/src/Scantable.cpp

@@ -543 +543 @@
     // take the first POLNO,IFNO,CYCLENO as nbeam shouldn't vary with these
     Table t = table_(table_.col("SCANNO") == scanno);
-    if ( t.nrow() == 0 ) return 0 ;
     ROTableRow row(t);
     const TableRecord& rec = row.get(0);
@@ -564 +563 @@
     // take the first POLNO,BEAMNO,CYCLENO as nbeam shouldn't vary with these
     Table t = table_(table_.col("SCANNO") == scanno);
-    if ( t.nrow() == 0 ) return 0 ;
     ROTableRow row(t);
     const TableRecord& rec = row.get(0);
@@ -586 +584 @@
     // take the first POLNO,IFNO,CYCLENO as nbeam shouldn't vary with these
     Table t = table_(table_.col("SCANNO") == scanno);
-    if ( t.nrow() == 0 ) return 0 ;
     ROTableRow row(t);
     const TableRecord& rec = row.get(0);
@@ -614 +611 @@
   } else {
     Table t = table_(table_.col("SCANNO") == scanno);
-    if ( t.nrow() == 0 ) return 0 ;
     ROTableRow row(t);
     const TableRecord& rec = row.get(0);
@@ -1754 +1750 @@
 }
 
-void Scantable::polyBaselineBatch(const std::vector<bool>& mask, int order, int rowno)
+void Scantable::polyBaselineBatch(const std::vector<bool>& mask, int order)
+{
+  Fitter fitter = Fitter();
+  for (uInt rowno=0; rowno < nrow(); ++rowno) {
+    doPolyBaseline(mask, order, rowno, fitter);
+    setSpectrum(fitter.getResidual(), rowno);
+  }
+}
+
+STFitEntry Scantable::polyBaseline(const std::vector<bool>& mask, int order, int rowno)
 {
   Fitter fitter = Fitter();
   doPolyBaseline(mask, order, rowno, fitter);
   setSpectrum(fitter.getResidual(), rowno);
-}
-
-void Scantable::polyBaseline(const std::vector<bool>& mask, int order, int rowno, long pars_ptr, long pars_size, long errs_ptr, long errs_size, long fmask_ptr, long fmask_size)
-{
-  Fitter fitter = Fitter();
-  doPolyBaseline(mask, order, rowno, fitter);
-  setSpectrum(fitter.getResidual(), rowno);
-
-  std::vector<float> pars = fitter.getParameters();
-  if (pars_size != pars.size()) {
-    throw(AipsError("wrong pars size"));
-  }
-  float *ppars = reinterpret_cast<float*>(pars_ptr);
-  for (int i = 0; i < pars_size; i++) {
-    ppars[i] = pars[i];
-  }
-
-  std::vector<float> errs = fitter.getErrors();
-  if (errs_size != errs.size()) {
-    throw(AipsError("wrong errors size"));
-  }
-  float *perrs = reinterpret_cast<float*>(errs_ptr);
-  for (int i = 0; i < errs_size; i++) {
-    perrs[i] = errs[i];
-  }
-
-  std::vector<bool> fmask = getMask(rowno);
-  if (fmask_size != fmask.size()) {
-    throw(AipsError("wrong fmask size"));
-  }
-  int *pfmask = reinterpret_cast<int*>(fmask_ptr);
-  for (int i = 0; i < fmask_size; i++) {
-    pfmask[i] = ((fmask[i] && mask[i]) ? 1 : 0);
-  }
+  return fitter.getFitEntry();
 }
 

trunk/src/Scantable.h

@@ -18 +18 @@
 // AIPS++
 #include <casa/aips.h>
+#include <casa/Containers/Record.h>
 #include <casa/Arrays/MaskedArray.h>
 #include <casa/BasicSL/String.h>
@@ -489 +490 @@
   bool getFlagtraFast(int whichrow);
 
-  void polyBaselineBatch(const std::vector<bool>& mask, int order, int rowno);
-  void polyBaseline(const std::vector<bool>& mask, int order, int rowno, long pars_ptr, long pars_size, long errs_ptr, long errs_size, long fmask_ptr, long fmask_size);
-
+  void polyBaselineBatch(const std::vector<bool>& mask, int order);
+  STFitEntry polyBaseline(const std::vector<bool>& mask, int order, int rowno);
 
 private:

trunk/src/ScantableWrapper.h

@@ -19 +19 @@
 #include "MathUtils.h"
 #include "STFit.h"
+#include "STFitEntry.h"
 #include "Scantable.h"
 #include "STCoordinate.h"
@@ -250 +251 @@
   { table_->reshapeSpectrum( nmin, nmax ); }
 
-  void polyBaseline(const std::vector<bool>& mask, int order, int rowno, long pars_ptr, long pars_size, long errs_ptr, long errs_size, long fmask_ptr, long fmask_size)
-  { table_->polyBaseline(mask, order, rowno, pars_ptr, pars_size, errs_ptr, errs_size, fmask_ptr, fmask_size); }
-
-  void polyBaselineBatch(const std::vector<bool>& mask, int order, int rowno)
-  { table_->polyBaselineBatch(mask, order, rowno); }
+  STFitEntry polyBaseline(const std::vector<bool>& mask, int order, int rowno)
+  { return table_->polyBaseline(mask, order, rowno); }
+
+  void polyBaselineBatch(const std::vector<bool>& mask, int order)
+  { table_->polyBaselineBatch(mask, order); }
 
   bool getFlagtraFast(int whichrow=0) const