Changeset 1931 for trunk


Ignore:
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:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/python/scantable.py

    r1928 r1931  
    337337        Parameters:
    338338
    339             filename:    the name of a file to write the output to
     339            filename:    the name of a file to write the putput to
    340340                         Default - no file output
    341341
     
    377377
    378378    def set_spectrum(self, spec, rowno):
    379         """Set the spectrum for the current row in the scantable.
     379        """Return the spectrum for the current row in the scantable as a list.
    380380
    381381        Parameters:
     
    738738        """\
    739739        Get a list of time stamps for the observations.
    740         Return a datetime object or a string (default) for each
    741         integration time stamp in the scantable.
     740        Return a datetime object for each integration time stamp in the scantable.
    742741
    743742        Parameters:
     
    11591158        return msk
    11601159
    1161     def get_masklist(self, mask=None, row=0):
     1160    def get_masklist(self, mask=None, row=0, silent=False):
    11621161        """\
    11631162        Compute and return a list of mask windows, [min, max].
     
    11931192        if not i:
    11941193            msg += "\nThis mask is only valid for IF=%d" % (self.getif(i))
    1195         asaplog.push(msg)
     1194        if not silent:
     1195            asaplog.push(msg)
    11961196        masklist=[]
    11971197        ist, ien = None, None
     
    12841284        """\
    12851285        Set or replace the restfrequency specified and
    1286         if the 'freqs' argument holds a scalar,
     1286        If the 'freqs' argument holds a scalar,
    12871287        then that rest frequency will be applied to all the selected
    12881288        data.  If the 'freqs' argument holds
     
    14341434                out += "Function: %s\n  Parameters:" % (func)
    14351435                for i in items:
    1436                     if i == '':
    1437                         continue
    14381436                    s = i.split("=")
    14391437                    out += "\n   %s = %s" % (s[0], s[1])
     
    19371935                workscan._setspectrum(f.fitter.getresidual(), r)
    19381936                self.blpars.append(f.get_parameters())
    1939                 self.masklists.append(workscan.get_masklist(f.mask, row=r))
     1937                self.masklists.append(workscan.get_masklist(f.mask, row=r, silent=True))
    19401938                self.actualmask.append(f.mask)
    19411939
     
    19521950            raise RuntimeError(msg)
    19531951
    1954 
     1952    @asaplog_post_dec
    19551953    def poly_baseline(self, mask=None, order=0, plot=False, batch=False, insitu=None, rows=None):
    19561954        """\
     
    19681966                        Otherwise, the scaling is done in-situ
    19691967                        The default is taken from .asaprc (False)
    1970             rows:       row numbers of spectra to be processed.
     1968            rows:       row numbers of spectra to be baselined.
    19711969                        (default is None: for all rows)
    19721970        Example:
     
    19751973            bscan = scan.poly_baseline(order=3)
    19761974        """
     1975       
     1976        varlist = vars()
     1977       
    19771978        if insitu is None: insitu = rcParams["insitu"]
    19781979        if insitu:
     
    19811982            workscan = self.copy()
    19821983
    1983         varlist = vars()
    19841984        nchan = workscan.nchan()
    19851985       
     
    19941994           
    19951995            if len(rows) > 0:
    1996                 self.blpars = []
    1997                 self.masklists = []
    1998                 self.actualmask = []
     1996                workscan.blpars = []
     1997                workscan.masklists = []
     1998                workscan.actualmask = []
    19991999
    20002000            if batch:
    2001                 for r in rows:
    2002                     workscan._poly_baseline_batch(mask, order, r)
     2001                workscan._poly_baseline_batch(mask, order)
    20032002            elif plot:
    20042003                f = fitter()
     
    20192018                        continue
    20202019                    workscan._setspectrum(f.fitter.getresidual(), r)
    2021                     self.blpars.append(f.get_parameters())
    2022                     self.masklists.append(workscan.get_masklist(f.mask, row=r))
    2023                     self.actualmask.append(f.mask)
     2020                    workscan.blpars.append(f.get_parameters())
     2021                    workscan.masklists.append(workscan.get_masklist(f.mask, row=r))
     2022                    workscan.actualmask.append(f.mask)
    20242023                   
    20252024                f._p.unmap()
    20262025                f._p = None
    20272026            else:
    2028                 import array
    20292027                for r in rows:
    2030                     pars = array.array("f", [0.0 for i in range(order+1)])
    2031                     pars_adr = pars.buffer_info()[0]
    2032                     pars_len = pars.buffer_info()[1]
     2028                    fitparams = workscan._poly_baseline(mask, order, r)
     2029                    params = fitparams.getparameters()
     2030                    fmtd = ", ".join(["p%d = %3.6f" % (i, v) for i, v in enumerate(params)])
     2031                    errors = fitparams.geterrors()
     2032                    fmask = mask_and(mask, workscan._getmask(r))
     2033
     2034                    workscan.blpars.append({"params":params,
     2035                                            "fixed": fitparams.getfixedparameters(),
     2036                                            "formatted":fmtd, "errors":errors})
     2037                    workscan.masklists.append(workscan.get_masklist(fmask, r, silent=True))
     2038                    workscan.actualmask.append(fmask)
    20332039                   
    2034                     errs = array.array("f", [0.0 for i in range(order+1)])
    2035                     errs_adr = errs.buffer_info()[0]
    2036                     errs_len = errs.buffer_info()[1]
    2037                    
    2038                     fmsk = array.array("i", [1 for i in range(nchan)])
    2039                     fmsk_adr = fmsk.buffer_info()[0]
    2040                     fmsk_len = fmsk.buffer_info()[1]
    2041                    
    2042                     workscan._poly_baseline(mask, order, r, pars_adr, pars_len, errs_adr, errs_len, fmsk_adr, fmsk_len)
    2043                    
    2044                     params = pars.tolist()
    2045                     fmtd = ""
    2046                     for i in xrange(len(params)): fmtd += "  p%d= %3.6f," % (i, params[i])
    2047                     fmtd = fmtd[:-1]  # remove trailing ","
    2048                     errors = errs.tolist()
    2049                     fmask = fmsk.tolist()
    2050                     for i in xrange(len(fmask)): fmask[i] = (fmask[i] > 0)    # transform (1/0) -> (True/False)
    2051                    
    2052                     self.blpars.append({"params":params, "fixed":[], "formatted":fmtd, "errors":errors})
    2053                     self.masklists.append(workscan.get_masklist(fmask, r))
    2054                     self.actualmask.append(fmask)
    2055                    
    2056                     asaplog.push(str(fmtd))
     2040                    asaplog.push(fmtd)
    20572041           
    20582042            workscan._add_history("poly_baseline", varlist)
     
    20772061                           insitu=None, rows=None):
    20782062        """\
    2079         Return a scan which has been baselined (all rows by default)
    2080         by a polynomial.
     2063        Return a scan which has been baselined (all rows) by a polynomial.
    20812064        Spectral lines are detected first using linefinder and masked out
    20822065        to avoid them affecting the baseline solution.
     
    22062189
    22072190            # Show mask list
    2208             masklist=workscan.get_masklist(f.mask, row=r)
     2191            masklist=workscan.get_masklist(f.mask, row=r, silent=True)
    22092192            msg = "mask range: "+str(masklist)
    22102193            asaplog.push(msg, False)
     
    23232306        """\
    23242307
    2325         Return a scan where all spectra are scaled by the given 'factor'
     2308        Return a scan where all spectra are scaled by the give 'factor'
    23262309
    23272310        Parameters:
  • trunk/src/Scantable.cpp

    r1929 r1931  
    543543    // take the first POLNO,IFNO,CYCLENO as nbeam shouldn't vary with these
    544544    Table t = table_(table_.col("SCANNO") == scanno);
    545     if ( t.nrow() == 0 ) return 0 ;
    546545    ROTableRow row(t);
    547546    const TableRecord& rec = row.get(0);
     
    564563    // take the first POLNO,BEAMNO,CYCLENO as nbeam shouldn't vary with these
    565564    Table t = table_(table_.col("SCANNO") == scanno);
    566     if ( t.nrow() == 0 ) return 0 ;
    567565    ROTableRow row(t);
    568566    const TableRecord& rec = row.get(0);
     
    586584    // take the first POLNO,IFNO,CYCLENO as nbeam shouldn't vary with these
    587585    Table t = table_(table_.col("SCANNO") == scanno);
    588     if ( t.nrow() == 0 ) return 0 ;
    589586    ROTableRow row(t);
    590587    const TableRecord& rec = row.get(0);
     
    614611  } else {
    615612    Table t = table_(table_.col("SCANNO") == scanno);
    616     if ( t.nrow() == 0 ) return 0 ;
    617613    ROTableRow row(t);
    618614    const TableRecord& rec = row.get(0);
     
    17541750}
    17551751
    1756 void Scantable::polyBaselineBatch(const std::vector<bool>& mask, int order, int rowno)
     1752void Scantable::polyBaselineBatch(const std::vector<bool>& mask, int order)
     1753{
     1754  Fitter fitter = Fitter();
     1755  for (uInt rowno=0; rowno < nrow(); ++rowno) {
     1756    doPolyBaseline(mask, order, rowno, fitter);
     1757    setSpectrum(fitter.getResidual(), rowno);
     1758  }
     1759}
     1760
     1761STFitEntry Scantable::polyBaseline(const std::vector<bool>& mask, int order, int rowno)
    17571762{
    17581763  Fitter fitter = Fitter();
    17591764  doPolyBaseline(mask, order, rowno, fitter);
    17601765  setSpectrum(fitter.getResidual(), rowno);
    1761 }
    1762 
    1763 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)
    1764 {
    1765   Fitter fitter = Fitter();
    1766   doPolyBaseline(mask, order, rowno, fitter);
    1767   setSpectrum(fitter.getResidual(), rowno);
    1768 
    1769   std::vector<float> pars = fitter.getParameters();
    1770   if (pars_size != pars.size()) {
    1771     throw(AipsError("wrong pars size"));
    1772   }
    1773   float *ppars = reinterpret_cast<float*>(pars_ptr);
    1774   for (int i = 0; i < pars_size; i++) {
    1775     ppars[i] = pars[i];
    1776   }
    1777 
    1778   std::vector<float> errs = fitter.getErrors();
    1779   if (errs_size != errs.size()) {
    1780     throw(AipsError("wrong errors size"));
    1781   }
    1782   float *perrs = reinterpret_cast<float*>(errs_ptr);
    1783   for (int i = 0; i < errs_size; i++) {
    1784     perrs[i] = errs[i];
    1785   }
    1786 
    1787   std::vector<bool> fmask = getMask(rowno);
    1788   if (fmask_size != fmask.size()) {
    1789     throw(AipsError("wrong fmask size"));
    1790   }
    1791   int *pfmask = reinterpret_cast<int*>(fmask_ptr);
    1792   for (int i = 0; i < fmask_size; i++) {
    1793     pfmask[i] = ((fmask[i] && mask[i]) ? 1 : 0);
    1794   }
     1766  return fitter.getFitEntry();
    17951767}
    17961768
  • trunk/src/Scantable.h

    r1919 r1931  
    1818// AIPS++
    1919#include <casa/aips.h>
     20#include <casa/Containers/Record.h>
    2021#include <casa/Arrays/MaskedArray.h>
    2122#include <casa/BasicSL/String.h>
     
    489490  bool getFlagtraFast(int whichrow);
    490491
    491   void polyBaselineBatch(const std::vector<bool>& mask, int order, int rowno);
    492   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);
    493 
     492  void polyBaselineBatch(const std::vector<bool>& mask, int order);
     493  STFitEntry polyBaseline(const std::vector<bool>& mask, int order, int rowno);
    494494
    495495private:
  • trunk/src/ScantableWrapper.h

    r1919 r1931  
    1919#include "MathUtils.h"
    2020#include "STFit.h"
     21#include "STFitEntry.h"
    2122#include "Scantable.h"
    2223#include "STCoordinate.h"
     
    250251  { table_->reshapeSpectrum( nmin, nmax ); }
    251252
    252   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)
    253   { table_->polyBaseline(mask, order, rowno, pars_ptr, pars_size, errs_ptr, errs_size, fmask_ptr, fmask_size); }
    254 
    255   void polyBaselineBatch(const std::vector<bool>& mask, int order, int rowno)
    256   { table_->polyBaselineBatch(mask, order, rowno); }
     253  STFitEntry polyBaseline(const std::vector<bool>& mask, int order, int rowno)
     254  { return table_->polyBaseline(mask, order, rowno); }
     255
     256  void polyBaselineBatch(const std::vector<bool>& mask, int order)
     257  { table_->polyBaselineBatch(mask, order); }
    257258
    258259  bool getFlagtraFast(int whichrow=0) const
Note: See TracChangeset for help on using the changeset viewer.