Changeset 2276 for trunk/python


Ignore:
Timestamp:
08/17/11 10:54:03 (13 years ago)
Author:
Malte Marquarding
Message:

Created 3.1.0 release tag

Location:
trunk/python
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/python/asapplotter.py

    r2173 r2276  
    914914                n = min(n,self._rows*self._cols)
    915915                self._plotter.set_panels(rows=self._rows,cols=self._cols,
    916                                          nplots=n,margin=self._margins,ganged=ganged)
     916                                         nplots=n,margin=self._margins,
     917                                         ganged=ganged)
    917918            else:
    918919                n = min(n,maxpanel)
    919                 self._plotter.set_panels(rows=n,cols=0,nplots=n,margin=self._margins,ganged=ganged)
     920                self._plotter.set_panels(rows=n,cols=0,nplots=n,
     921                                         margin=self._margins,ganged=ganged)
    920922        else:
    921923            self._plotter.set_panels(margin=self._margins)
    … …  
    972974                   
    973975            #if (b > b0 or newpanel) and stackcount < nstack:
    974             if stackcount < nstack and (newpanel or rowstack or (a == a0 and b > b0)):
     976            if stackcount < nstack and (newpanel or rowstack
     977                                        or (a == a0 and b > b0)):
    975978                y = []
    976979                if len(polmodes):
    … …  
    980983                # flag application
    981984                mr = scan._getflagrow(r)
     985                #mr = False
    982986                from numpy import ma, array
    983987                if mr:
    … …  
    987991                    from numpy import logical_not, logical_and
    988992                    if self._maskselection and len(self._usermask) == len(m):
    989                         if d[self._stacking](r) in self._maskselection[self._stacking]:
     993                        if d[self._stacking](r) in \
     994                                self._maskselection[self._stacking]:
    990995                            m = logical_and(m, self._usermask)
    991                     y = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
     996                    y = ma.masked_array(y,mask=logical_not(array(m,
     997                                                                 copy=False)))
    992998
    993999                x = array(scan._getabcissa(r))

  • trunk/python/scantable.py

    r2269 r2276  
    8888            * an integer - will be used for both sides of spectra of all IFs.
    8989                  e.g. 10 is converted to [10,10]
    90             * an empty list/tuple [] - converted to [0, 0] and used for all IFs.
     90            * an empty list/tuple [] - converted to [0, 0] and used for all
     91              IFs.
    9192            * a list/tuple containing an integer - same as the above case.
    9293                  e.g. [10] is converted to [10,10]
    … …  
    9596            * a list/tuple of lists/tuples containing TWO integers -
    9697                  each element of edge will be used for each IF.
    97                   e.g. [[5,10],[15,20]] - [5,10] for IF[0] and [15,20] for IF[1].
    98                  
    99                   If an element contains the same integer values, the input 'edge'
    100                   parameter can be given in a simpler shape in the following cases:
     98                  e.g. [[5,10],[15,20]] - [5,10] for IF[0] and [15,20] for
     99                  IF[1].
     100                  If an element contains the same integer values, the input
     101                  'edge' parameter can be given in a simpler shape in the
     102                  following cases:
    101103                      ** when len(edge)!=2
    102                           any elements containing the same values can be replaced
    103                           to single integers.
    104                           e.g. [[15,15]] can be simplified to [15] (or [15,15] or 15 also).
    105                           e.g. [[1,1],[2,2],[3,3]] can be simplified to [1,2,3].
     104                          any elements containing the same values can be
     105                          replaced to single integers.
     106                          e.g. [[15,15]] can be simplified to [15]
     107                          (or [15,15] or 15 also).
     108                          e.g. [[1,1],[2,2],[3,3]] can be simplified to
     109                          [1,2,3].
    106110                      ** when len(edge)=2
    107111                          care is needed for this case: ONLY ONE of the
    108112                          elements can be a single integer,
    109113                          e.g. [[5,5],[10,10]] can be simplified to [5,[10,10]]
    110                                or [[5,5],10], but can NOT be simplified to [5,10].
     114                               or [[5,5],10], but can NOT be simplified to
     115                               [5,10].
    111116                               when [5,10] given, it is interpreted as
    112                                [[5,10],[5,10],[5,10],...] instead, as shown before.
     117                               [[5,10],[5,10],[5,10],...] instead, as shown
     118                               before.
    113119    """
    114120    from asap import _is_sequence_or_number as _is_valid
    … …  
    181187    #def __init__(self, filename, average=None, unit=None, getpt=None,
    182188    #             antenna=None, parallactify=None):
    183     def __init__(self, filename, average=None, unit=None, parallactify=None, **args):
     189    def __init__(self, filename, average=None, unit=None, parallactify=None,
     190                 **args):
    184191        """\
    185192        Create a scantable from a saved one or make a reference
    … …  
    208215
    209216            antenna:      for MeasurementSet input data only:
    210                           Antenna selection. integer (id) or string (name or id).
     217                          Antenna selection. integer (id) or string (name
     218                          or id).
    211219
    212220            parallactify: Indicate that the data had been parallatified. Default
    … …  
    302310                            * 'ASCII' (saves as ascii text file)
    303311                            * 'MS2' (saves as an casacore MeasurementSet V2)
    304                             * 'FITS' (save as image FITS - not readable by class)
     312                            * 'FITS' (save as image FITS - not readable by
     313                              CLASS)
    305314                            * 'CLASS' (save as FITS readable by CLASS)
    306315
    … …  
    370379        from asap import unique
    371380        if not _is_valid(scanid):
    372             raise RuntimeError( 'Please specify a scanno to drop from the scantable' )
     381            raise RuntimeError( 'Please specify a scanno to drop from the '\
     382                                'scantable' )
    373383        scanid = _to_list(scanid)
    374384        allscans = unique([ self.getscan(i) for i in range(self.nrow())])
    … …  
    852862            asdatetime:   return values as datetime objects rather than strings
    853863
    854             prec:         number of digits shown. Default -1 to automatic calculation.
     864            prec:         number of digits shown. Default -1 to automatic
     865                          calculation.
    855866                          Note this number is equals to the digits of MVTime,
    856867                          i.e., 0<prec<3: dates with hh:: only,
    … …  
    11451156
    11461157            rows:   list of row numbers to be flagged. Default is no row
    1147                     (must be explicitly specified to execute row-based flagging).
     1158                    (must be explicitly specified to execute row-based
     1159                    flagging).
    11481160
    11491161            unflag: if True, unflag the data.
    … …  
    11651177            dthres:      lower threshold
    11661178
    1167             clipoutside: True for flagging data outside the range [dthres:uthres].
     1179            clipoutside: True for flagging data outside the range
     1180                         [dthres:uthres].
    11681181                         False for flagging data inside the range.
    11691182
    … …  
    22552268            return [ wn ]
    22562269        elif isinstance(wn, str):
    2257             if '-' in wn:                            # case 'a-b' : return [a,a+1,...,b-1,b]
     2270            if '-' in wn:                           
     2271                # case 'a-b' : return [a,a+1,...,b-1,b]
    22582272                val = wn.split('-')
    22592273                val = [int(val[0]), int(val[1])]
    22602274                val.sort()
    22612275                res = [i for i in xrange(val[0], val[1]+1)]
    2262             elif wn[:2] == '<=' or wn[:2] == '=<':   # cases '<=a','=<a' : return [0,1,...,a-1,a]
     2276            elif wn[:2] == '<=' or wn[:2] == '=<':
     2277                # cases '<=a','=<a' : return [0,1,...,a-1,a]
    22632278                val = int(wn[2:])+1
    22642279                res = [i for i in xrange(val)]
    2265             elif wn[-2:] == '>=' or wn[-2:] == '=>': # cases 'a>=','a=>' : return [0,1,...,a-1,a]
     2280            elif wn[-2:] == '>=' or wn[-2:] == '=>':
     2281                # cases 'a>=','a=>' : return [0,1,...,a-1,a]
    22662282                val = int(wn[:-2])+1
    22672283                res = [i for i in xrange(val)]
    2268             elif wn[0] == '<':                       # case '<a' :         return [0,1,...,a-2,a-1]
     2284            elif wn[0] == '<':                     
     2285                # case '<a' :         return [0,1,...,a-2,a-1]
    22692286                val = int(wn[1:])
    22702287                res = [i for i in xrange(val)]
    2271             elif wn[-1] == '>':                      # case 'a>' :         return [0,1,...,a-2,a-1]
     2288            elif wn[-1] == '>':                     
     2289                # case 'a>' :         return [0,1,...,a-2,a-1]
    22722290                val = int(wn[:-1])
    22732291                res = [i for i in xrange(val)]
    2274             elif wn[:2] == '>=' or wn[:2] == '=>':   # cases '>=a','=>a' : return [a,a+1,...,a_nyq]
     2292            elif wn[:2] == '>=' or wn[:2] == '=>':
     2293                # cases '>=a','=>a' : return [a,a+1,...,a_nyq]
    22752294                val = int(wn[2:])
    22762295                res = [i for i in xrange(val, self.nchan()/2+1)]
    2277             elif wn[-2:] == '<=' or wn[-2:] == '=<': # cases 'a<=','a=<' : return [a,a+1,...,a_nyq]
     2296            elif wn[-2:] == '<=' or wn[-2:] == '=<':
     2297                # cases 'a<=','a=<' : return [a,a+1,...,a_nyq]
    22782298                val = int(wn[:-2])
    22792299                res = [i for i in xrange(val, self.nchan()/2+1)]
    2280             elif wn[0] == '>':                       # case '>a' :         return [a+1,a+2,...,a_nyq]
     2300            elif wn[0] == '>':
     2301                # case '>a' :         return [a+1,a+2,...,a_nyq]
    22812302                val = int(wn[1:])+1
    22822303                res = [i for i in xrange(val, self.nchan()/2+1)]
    2283             elif wn[-1] == '<':                      # case 'a<' :         return [a+1,a+2,...,a_nyq]
     2304            elif wn[-1] == '<':
     2305                # case 'a<' :         return [a+1,a+2,...,a_nyq]
    22842306                val = int(wn[:-1])+1
    22852307                res = [i for i in xrange(val, self.nchan()/2+1)]
    … …  
    22922314
    22932315    @asaplog_post_dec
    2294     def sinusoid_baseline(self, insitu=None, mask=None, applyfft=None,
     2316    def sinusoid_baseline(self, mask=None, insitu=None, applyfft=None,
    22952317                          fftmethod=None, fftthresh=None,
    22962318                          addwn=None, rejwn=None, clipthresh=None,
    … …  
    23722394                workscan = self.copy()
    23732395           
    2374             if mask          is None: mask          = [True for i in xrange(workscan.nchan())]
     2396            if mask          is None: mask          = \
     2397                    [True for i in xrange(workscan.nchan())]
    23752398            if applyfft      is None: applyfft      = True
    23762399            if fftmethod     is None: fftmethod     = 'fft'
    … …  
    23882411
    23892412            #CURRENTLY, PLOT=true is UNAVAILABLE UNTIL sinusoidal fitting is implemented as a fitter method.
    2390             workscan._sinusoid_baseline(mask, applyfft, fftmethod.lower(), str(fftthresh).lower(), workscan._parse_wn(addwn), workscan._parse_wn(rejwn), clipthresh, clipniter, getresidual, pack_progress_params(showprogress, minnrow), outlog, blfile)
     2413            workscan._sinusoid_baseline(mask, applyfft, fftmethod.lower(),
     2414                                        str(fftthresh).lower(),
     2415                                        workscan._parse_wn(addwn),
     2416                                        workscan._parse_wn(rejwn), clipthresh,
     2417                                        clipniter, getresidual,
     2418                                        pack_progress_params(showprogress,
     2419                                                             minnrow),
     2420                                        outlog, blfile)
    23912421            workscan._add_history('sinusoid_baseline', varlist)
    23922422           
    … …  
    24012431
    24022432    @asaplog_post_dec
    2403     def auto_sinusoid_baseline(self, insitu=None, mask=None, applyfft=None, fftmethod=None, fftthresh=None,
    2404                                addwn=None, rejwn=None, clipthresh=None, clipniter=None, edge=None, threshold=None,
    2405                                chan_avg_limit=None, plot=None, getresidual=None, showprogress=None, minnrow=None,
     2433    def auto_sinusoid_baseline(self, mask=None, insitu=None, applyfft=None,
     2434                               fftmethod=None, fftthresh=None,
     2435                               addwn=None, rejwn=None, clipthresh=None,
     2436                               clipniter=None, edge=None, threshold=None,
     2437                               chan_avg_limit=None, plot=None,
     2438                               getresidual=None, showprogress=None,
     2439                               minnrow=None,
    24062440                               outlog=None, blfile=None):
    24072441        """\
    2408         Return a scan which has been baselined (all rows) with sinusoidal functions.
     2442        Return a scan which has been baselined (all rows) with sinusoidal
     2443        functions.
    24092444        Spectral lines are detected first using linefinder and masked out
    24102445        to avoid them affecting the baseline solution.
    … …  
    24272462                            given a float value, the unit is set to sigma.
    24282463                            for string values, allowed formats include:
    2429                                 'xsigma' or 'x' (= x-sigma level. e.g., '3sigma'), or
     2464                                'xsigma' or 'x' (= x-sigma level. e.g.,
     2465                                 '3sigma'), or
    24302466                                'topx' (= the x strongest ones, e.g. 'top5').
    24312467                            default is 3.0 (unit: sigma).
    … …  
    24452481                            and rejwn will NOT be used. default is [].
    24462482            clipthresh:     Clipping threshold. (default is 3.0, unit: sigma)
    2447             clipniter:      maximum number of iteration of 'clipthresh'-sigma clipping (default is 0)
     2483            clipniter:      maximum number of iteration of 'clipthresh'-sigma
     2484                            clipping (default is 0)
    24482485            edge:           an optional number of channel to drop at
    24492486                            the edge of spectrum. If only one value is
    … …  
    24992536                workscan = self.copy()
    25002537           
    2501             if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
     2538            if mask           is None: mask           = \
     2539                    [True for i in xrange(workscan.nchan())]
    25022540            if applyfft       is None: applyfft       = True
    25032541            if fftmethod      is None: fftmethod      = 'fft'
    … …  
    25172555            if blfile         is None: blfile         = ''
    25182556
    2519             #CURRENTLY, PLOT=true is UNAVAILABLE UNTIL sinusoidal fitting is implemented as a fitter method.
    2520             workscan._auto_sinusoid_baseline(mask, applyfft, fftmethod.lower(), str(fftthresh).lower(), workscan._parse_wn(addwn), workscan._parse_wn(rejwn), clipthresh, clipniter, normalise_edge_param(edge), threshold, chan_avg_limit, getresidual, pack_progress_params(showprogress, minnrow), outlog, blfile)
     2557            #CURRENTLY, PLOT=true is UNAVAILABLE UNTIL sinusoidal fitting is
     2558            # implemented as a fitter method.
     2559            workscan._auto_sinusoid_baseline(mask, applyfft, fftmethod.lower(),
     2560                                             str(fftthresh).lower(),
     2561                                             workscan._parse_wn(addwn),
     2562                                             workscan._parse_wn(rejwn),
     2563                                             clipthresh, clipniter,
     2564                                             normalise_edge_param(edge),
     2565                                             threshold, chan_avg_limit,
     2566                                             getresidual,
     2567                                             pack_progress_params(showprogress,
     2568                                                                  minnrow),
     2569                                             outlog, blfile)
    25212570            workscan._add_history("auto_sinusoid_baseline", varlist)
    25222571           
    … …  
    25302579
    25312580    @asaplog_post_dec
    2532     def cspline_baseline(self, insitu=None, mask=None, npiece=None, clipthresh=None, clipniter=None,
    2533                          plot=None, getresidual=None, showprogress=None, minnrow=None, outlog=None, blfile=None):
    2534         """\
    2535         Return a scan which has been baselined (all rows) by cubic spline function (piecewise cubic polynomial).
     2581    def cspline_baseline(self, mask=None, insitu=None, npiece=None,
     2582                         clipthresh=None, clipniter=None, plot=None,
     2583                         getresidual=None, showprogress=None, minnrow=None,
     2584                         outlog=None, blfile=None):
     2585        """\
     2586        Return a scan which has been baselined (all rows) by cubic spline
     2587        function (piecewise cubic polynomial).
    25362588        Parameters:
    25372589            insitu:       If False a new scantable is returned.
    … …  
    25412593            npiece:       Number of pieces. (default is 2)
    25422594            clipthresh:   Clipping threshold. (default is 3.0, unit: sigma)
    2543             clipniter:    maximum number of iteration of 'clipthresh'-sigma clipping (default is 0)
     2595            clipniter:    maximum number of iteration of 'clipthresh'-sigma
     2596                          clipping (default is 0)
    25442597            plot:     *** CURRENTLY UNAVAILABLE, ALWAYS FALSE ***
    25452598                          plot the fit and the residual. In this each
    … …  
    25592612
    25602613        Example:
    2561             # return a scan baselined by a cubic spline consisting of 2 pieces (i.e., 1 internal knot),
     2614            # return a scan baselined by a cubic spline consisting of 2
     2615            # pieces (i.e., 1 internal knot),
    25622616            # also with 3-sigma clipping, iteration up to 4 times
    25632617            bscan = scan.cspline_baseline(npiece=2,clipthresh=3.0,clipniter=4)
    … …  
    25772631                workscan = self.copy()
    25782632
    2579             if mask         is None: mask         = [True for i in xrange(workscan.nchan())]
     2633            if mask         is None: mask         = \
     2634                    [True for i in xrange(workscan.nchan())]
    25802635            if npiece       is None: npiece       = 2
    25812636            if clipthresh   is None: clipthresh   = 3.0
    … …  
    25892644
    25902645            #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method.
    2591             workscan._cspline_baseline(mask, npiece, clipthresh, clipniter, getresidual, pack_progress_params(showprogress, minnrow), outlog, blfile)
     2646            workscan._cspline_baseline(mask, npiece, clipthresh, clipniter,
     2647                                       getresidual,
     2648                                       pack_progress_params(showprogress,
     2649                                                            minnrow),
     2650                                       outlog, blfile)
    25922651            workscan._add_history("cspline_baseline", varlist)
    25932652           
    … …  
    26012660
    26022661    @asaplog_post_dec
    2603     def auto_cspline_baseline(self, insitu=None, mask=None, npiece=None, clipthresh=None, clipniter=None,
    2604                               edge=None, threshold=None, chan_avg_limit=None, getresidual=None, plot=None,
    2605                               showprogress=None, minnrow=None, outlog=None, blfile=None):
     2662    def auto_cspline_baseline(self, mask=None, insitu=None, npiece=None,
     2663                              clipthresh=None, clipniter=None,
     2664                              edge=None, threshold=None, chan_avg_limit=None,
     2665                              getresidual=None, plot=None,
     2666                              showprogress=None, minnrow=None, outlog=None,
     2667                              blfile=None):
    26062668        """\
    26072669        Return a scan which has been baselined (all rows) by cubic spline
    … …  
    26172679            npiece:         Number of pieces. (default is 2)
    26182680            clipthresh:     Clipping threshold. (default is 3.0, unit: sigma)
    2619             clipniter:      maximum number of iteration of 'clipthresh'-sigma clipping (default is 0)
     2681            clipniter:      maximum number of iteration of 'clipthresh'-sigma
     2682                            clipping (default is 0)
    26202683            edge:           an optional number of channel to drop at
    26212684                            the edge of spectrum. If only one value is
    … …  
    26712734                workscan = self.copy()
    26722735           
    2673             if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
     2736            if mask           is None: mask           = \
     2737                    [True for i in xrange(workscan.nchan())]
    26742738            if npiece         is None: npiece         = 2
    26752739            if clipthresh     is None: clipthresh     = 3.0
    … …  
    26852749            if blfile         is None: blfile         = ''
    26862750
    2687             #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method.
     2751            #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is
     2752            # implemented as a fitter method.
    26882753            workscan._auto_cspline_baseline(mask, npiece, clipthresh,
    26892754                                            clipniter,
    … …  
    27472812                workscan = self.copy()
    27482813
    2749             if mask         is None: mask         = [True for i in \
    2750                                                       xrange(workscan.nchan())]
     2814            if mask         is None: mask         = \
     2815                    [True for i in xrange(workscan.nchan())]
    27512816            if order        is None: order        = 0
    27522817            if plot         is None: plot         = False
    … …  
    28832948                workscan = self.copy()
    28842949
    2885             if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
     2950            if mask           is None: mask           = \
     2951                    [True for i in xrange(workscan.nchan())]
    28862952            if order          is None: order          = 0
    28872953            if edge           is None: edge           = (0, 0)
    … …  
    32953361            s = scantable(self._math._unaryop(self, other, "SUB", False))
    32963362        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
    3297             if isinstance(other[0], list) or isinstance(other[0], numpy.ndarray):
     3363            if isinstance(other[0], list) or isinstance(other[0],
     3364                                                        numpy.ndarray):
    32983365                from asapmath import _array2dOp
    32993366                s = _array2dOp( self.copy(), other, "SUB", False )
    33003367            else:
    3301                 s = scantable( self._math._arrayop( self.copy(), other, "SUB", False ) )
     3368                s = scantable( self._math._arrayop( self.copy(), other,
     3369                                                    "SUB", False ) )
    33023370        else:
    33033371            raise TypeError("Other input is not a scantable or float value")
    … …  
    33173385            s = scantable(self._math._unaryop(self, other, "MUL", False))
    33183386        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
    3319             if isinstance(other[0], list) or isinstance(other[0], numpy.ndarray):
     3387            if isinstance(other[0], list) or isinstance(other[0],
     3388                                                        numpy.ndarray):
    33203389                from asapmath import _array2dOp
    33213390                s = _array2dOp( self.copy(), other, "MUL", False )
    33223391            else:
    3323                 s = scantable( self._math._arrayop( self.copy(), other, "MUL", False ) )
     3392                s = scantable( self._math._arrayop( self.copy(), other,
     3393                                                    "MUL", False ) )
    33243394        else:
    33253395            raise TypeError("Other input is not a scantable or float value")
    … …  
    33423412            s = scantable(self._math._unaryop(self, other, "DIV", False))
    33433413        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
    3344             if isinstance(other[0], list) or isinstance(other[0], numpy.ndarray):
     3414            if isinstance(other[0], list) or isinstance(other[0],
     3415                                                        numpy.ndarray):
    33453416                from asapmath import _array2dOp
    33463417                s = _array2dOp( self.copy(), other, "DIV", False )
    33473418            else:
    3348                 s = scantable( self._math._arrayop( self.copy(), other, "DIV", False ) )
     3419                s = scantable( self._math._arrayop( self.copy(), other,
     3420                                                    "DIV", False ) )
    33493421        else:
    33503422            raise TypeError("Other input is not a scantable or float value")
Note: See TracChangeset for help on using the changeset viewer.