Changeset 1931 for trunk/python


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


File:
1 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:
Note: See TracChangeset for help on using the changeset viewer.