Changeset 2277 for trunk/python


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

revert accidental changes

Location:
trunk/python
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/python/asapplotter.py

    r2276 r2277  
    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,
    917                                          ganged=ganged)
     916                                         nplots=n,margin=self._margins,ganged=ganged)
    918917            else:
    919918                n = min(n,maxpanel)
    920                 self._plotter.set_panels(rows=n,cols=0,nplots=n,
    921                                          margin=self._margins,ganged=ganged)
     919                self._plotter.set_panels(rows=n,cols=0,nplots=n,margin=self._margins,ganged=ganged)
    922920        else:
    923921            self._plotter.set_panels(margin=self._margins)
    … …  
    974972                   
    975973            #if (b > b0 or newpanel) and stackcount < nstack:
    976             if stackcount < nstack and (newpanel or rowstack
    977                                         or (a == a0 and b > b0)):
     974            if stackcount < nstack and (newpanel or rowstack or (a == a0 and b > b0)):
    978975                y = []
    979976                if len(polmodes):
    … …  
    983980                # flag application
    984981                mr = scan._getflagrow(r)
    985                 #mr = False
    986982                from numpy import ma, array
    987983                if mr:
    … …  
    991987                    from numpy import logical_not, logical_and
    992988                    if self._maskselection and len(self._usermask) == len(m):
    993                         if d[self._stacking](r) in \
    994                                 self._maskselection[self._stacking]:
     989                        if d[self._stacking](r) in self._maskselection[self._stacking]:
    995990                            m = logical_and(m, self._usermask)
    996                     y = ma.masked_array(y,mask=logical_not(array(m,
    997                                                                  copy=False)))
     991                    y = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
    998992
    999993                x = array(scan._getabcissa(r))

  • trunk/python/scantable.py

    r2276 r2277  
    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
    91               IFs.
     90            * an empty list/tuple [] - converted to [0, 0] and used for all IFs.
    9291            * a list/tuple containing an integer - same as the above case.
    9392                  e.g. [10] is converted to [10,10]
    … …  
    9695            * a list/tuple of lists/tuples containing TWO integers -
    9796                  each element of edge will be used for each IF.
    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:
     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:
    103101                      ** when len(edge)!=2
    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].
     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].
    110106                      ** when len(edge)=2
    111107                          care is needed for this case: ONLY ONE of the
    112108                          elements can be a single integer,
    113109                          e.g. [[5,5],[10,10]] can be simplified to [5,[10,10]]
    114                                or [[5,5],10], but can NOT be simplified to
    115                                [5,10].
     110                               or [[5,5],10], but can NOT be simplified to [5,10].
    116111                               when [5,10] given, it is interpreted as
    117                                [[5,10],[5,10],[5,10],...] instead, as shown
    118                                before.
     112                               [[5,10],[5,10],[5,10],...] instead, as shown before.
    119113    """
    120114    from asap import _is_sequence_or_number as _is_valid
    … …  
    187181    #def __init__(self, filename, average=None, unit=None, getpt=None,
    188182    #             antenna=None, parallactify=None):
    189     def __init__(self, filename, average=None, unit=None, parallactify=None,
    190                  **args):
     183    def __init__(self, filename, average=None, unit=None, parallactify=None, **args):
    191184        """\
    192185        Create a scantable from a saved one or make a reference
    … …  
    215208
    216209            antenna:      for MeasurementSet input data only:
    217                           Antenna selection. integer (id) or string (name
    218                           or id).
     210                          Antenna selection. integer (id) or string (name or id).
    219211
    220212            parallactify: Indicate that the data had been parallatified. Default
    … …  
    310302                            * 'ASCII' (saves as ascii text file)
    311303                            * 'MS2' (saves as an casacore MeasurementSet V2)
    312                             * 'FITS' (save as image FITS - not readable by
    313                               CLASS)
     304                            * 'FITS' (save as image FITS - not readable by class)
    314305                            * 'CLASS' (save as FITS readable by CLASS)
    315306
    … …  
    379370        from asap import unique
    380371        if not _is_valid(scanid):
    381             raise RuntimeError( 'Please specify a scanno to drop from the '\
    382                                 'scantable' )
     372            raise RuntimeError( 'Please specify a scanno to drop from the scantable' )
    383373        scanid = _to_list(scanid)
    384374        allscans = unique([ self.getscan(i) for i in range(self.nrow())])
    … …  
    862852            asdatetime:   return values as datetime objects rather than strings
    863853
    864             prec:         number of digits shown. Default -1 to automatic
    865                           calculation.
     854            prec:         number of digits shown. Default -1 to automatic calculation.
    866855                          Note this number is equals to the digits of MVTime,
    867856                          i.e., 0<prec<3: dates with hh:: only,
    … …  
    11561145
    11571146            rows:   list of row numbers to be flagged. Default is no row
    1158                     (must be explicitly specified to execute row-based
    1159                     flagging).
     1147                    (must be explicitly specified to execute row-based flagging).
    11601148
    11611149            unflag: if True, unflag the data.
    … …  
    11771165            dthres:      lower threshold
    11781166
    1179             clipoutside: True for flagging data outside the range
    1180                          [dthres:uthres].
     1167            clipoutside: True for flagging data outside the range [dthres:uthres].
    11811168                         False for flagging data inside the range.
    11821169
    … …  
    22682255            return [ wn ]
    22692256        elif isinstance(wn, str):
    2270             if '-' in wn:                           
    2271                 # case 'a-b' : return [a,a+1,...,b-1,b]
     2257            if '-' in wn:                            # case 'a-b' : return [a,a+1,...,b-1,b]
    22722258                val = wn.split('-')
    22732259                val = [int(val[0]), int(val[1])]
    22742260                val.sort()
    22752261                res = [i for i in xrange(val[0], val[1]+1)]
    2276             elif wn[:2] == '<=' or wn[:2] == '=<':
    2277                 # cases '<=a','=<a' : return [0,1,...,a-1,a]
     2262            elif wn[:2] == '<=' or wn[:2] == '=<':   # cases '<=a','=<a' : return [0,1,...,a-1,a]
    22782263                val = int(wn[2:])+1
    22792264                res = [i for i in xrange(val)]
    2280             elif wn[-2:] == '>=' or wn[-2:] == '=>':
    2281                 # cases 'a>=','a=>' : return [0,1,...,a-1,a]
     2265            elif wn[-2:] == '>=' or wn[-2:] == '=>': # cases 'a>=','a=>' : return [0,1,...,a-1,a]
    22822266                val = int(wn[:-2])+1
    22832267                res = [i for i in xrange(val)]
    2284             elif wn[0] == '<':                     
    2285                 # case '<a' :         return [0,1,...,a-2,a-1]
     2268            elif wn[0] == '<':                       # case '<a' :         return [0,1,...,a-2,a-1]
    22862269                val = int(wn[1:])
    22872270                res = [i for i in xrange(val)]
    2288             elif wn[-1] == '>':                     
    2289                 # case 'a>' :         return [0,1,...,a-2,a-1]
     2271            elif wn[-1] == '>':                      # case 'a>' :         return [0,1,...,a-2,a-1]
    22902272                val = int(wn[:-1])
    22912273                res = [i for i in xrange(val)]
    2292             elif wn[:2] == '>=' or wn[:2] == '=>':
    2293                 # cases '>=a','=>a' : return [a,a+1,...,a_nyq]
     2274            elif wn[:2] == '>=' or wn[:2] == '=>':   # cases '>=a','=>a' : return [a,a+1,...,a_nyq]
    22942275                val = int(wn[2:])
    22952276                res = [i for i in xrange(val, self.nchan()/2+1)]
    2296             elif wn[-2:] == '<=' or wn[-2:] == '=<':
    2297                 # cases 'a<=','a=<' : return [a,a+1,...,a_nyq]
     2277            elif wn[-2:] == '<=' or wn[-2:] == '=<': # cases 'a<=','a=<' : return [a,a+1,...,a_nyq]
    22982278                val = int(wn[:-2])
    22992279                res = [i for i in xrange(val, self.nchan()/2+1)]
    2300             elif wn[0] == '>':
    2301                 # case '>a' :         return [a+1,a+2,...,a_nyq]
     2280            elif wn[0] == '>':                       # case '>a' :         return [a+1,a+2,...,a_nyq]
    23022281                val = int(wn[1:])+1
    23032282                res = [i for i in xrange(val, self.nchan()/2+1)]
    2304             elif wn[-1] == '<':
    2305                 # case 'a<' :         return [a+1,a+2,...,a_nyq]
     2283            elif wn[-1] == '<':                      # case 'a<' :         return [a+1,a+2,...,a_nyq]
    23062284                val = int(wn[:-1])+1
    23072285                res = [i for i in xrange(val, self.nchan()/2+1)]
    … …  
    23142292
    23152293    @asaplog_post_dec
    2316     def sinusoid_baseline(self, mask=None, insitu=None, applyfft=None,
     2294    def sinusoid_baseline(self, insitu=None, mask=None, applyfft=None,
    23172295                          fftmethod=None, fftthresh=None,
    23182296                          addwn=None, rejwn=None, clipthresh=None,
    … …  
    23942372                workscan = self.copy()
    23952373           
    2396             if mask          is None: mask          = \
    2397                     [True for i in xrange(workscan.nchan())]
     2374            if mask          is None: mask          = [True for i in xrange(workscan.nchan())]
    23982375            if applyfft      is None: applyfft      = True
    23992376            if fftmethod     is None: fftmethod     = 'fft'
    … …  
    24112388
    24122389            #CURRENTLY, PLOT=true is UNAVAILABLE UNTIL sinusoidal fitting is implemented as a fitter method.
    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)
     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)
    24212391            workscan._add_history('sinusoid_baseline', varlist)
    24222392           
    … …  
    24312401
    24322402    @asaplog_post_dec
    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,
     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,
    24402406                               outlog=None, blfile=None):
    24412407        """\
    2442         Return a scan which has been baselined (all rows) with sinusoidal
    2443         functions.
     2408        Return a scan which has been baselined (all rows) with sinusoidal functions.
    24442409        Spectral lines are detected first using linefinder and masked out
    24452410        to avoid them affecting the baseline solution.
    … …  
    24622427                            given a float value, the unit is set to sigma.
    24632428                            for string values, allowed formats include:
    2464                                 'xsigma' or 'x' (= x-sigma level. e.g.,
    2465                                  '3sigma'), or
     2429                                'xsigma' or 'x' (= x-sigma level. e.g., '3sigma'), or
    24662430                                'topx' (= the x strongest ones, e.g. 'top5').
    24672431                            default is 3.0 (unit: sigma).
    … …  
    24812445                            and rejwn will NOT be used. default is [].
    24822446            clipthresh:     Clipping threshold. (default is 3.0, unit: sigma)
    2483             clipniter:      maximum number of iteration of 'clipthresh'-sigma
    2484                             clipping (default is 0)
     2447            clipniter:      maximum number of iteration of 'clipthresh'-sigma clipping (default is 0)
    24852448            edge:           an optional number of channel to drop at
    24862449                            the edge of spectrum. If only one value is
    … …  
    25362499                workscan = self.copy()
    25372500           
    2538             if mask           is None: mask           = \
    2539                     [True for i in xrange(workscan.nchan())]
     2501            if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
    25402502            if applyfft       is None: applyfft       = True
    25412503            if fftmethod      is None: fftmethod      = 'fft'
    … …  
    25552517            if blfile         is None: blfile         = ''
    25562518
    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)
     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)
    25702521            workscan._add_history("auto_sinusoid_baseline", varlist)
    25712522           
    … …  
    25792530
    25802531    @asaplog_post_dec
    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).
     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).
    25882536        Parameters:
    25892537            insitu:       If False a new scantable is returned.
    … …  
    25932541            npiece:       Number of pieces. (default is 2)
    25942542            clipthresh:   Clipping threshold. (default is 3.0, unit: sigma)
    2595             clipniter:    maximum number of iteration of 'clipthresh'-sigma
    2596                           clipping (default is 0)
     2543            clipniter:    maximum number of iteration of 'clipthresh'-sigma clipping (default is 0)
    25972544            plot:     *** CURRENTLY UNAVAILABLE, ALWAYS FALSE ***
    25982545                          plot the fit and the residual. In this each
    … …  
    26122559
    26132560        Example:
    2614             # return a scan baselined by a cubic spline consisting of 2
    2615             # pieces (i.e., 1 internal knot),
     2561            # return a scan baselined by a cubic spline consisting of 2 pieces (i.e., 1 internal knot),
    26162562            # also with 3-sigma clipping, iteration up to 4 times
    26172563            bscan = scan.cspline_baseline(npiece=2,clipthresh=3.0,clipniter=4)
    … …  
    26312577                workscan = self.copy()
    26322578
    2633             if mask         is None: mask         = \
    2634                     [True for i in xrange(workscan.nchan())]
     2579            if mask         is None: mask         = [True for i in xrange(workscan.nchan())]
    26352580            if npiece       is None: npiece       = 2
    26362581            if clipthresh   is None: clipthresh   = 3.0
    … …  
    26442589
    26452590            #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method.
    2646             workscan._cspline_baseline(mask, npiece, clipthresh, clipniter,
    2647                                        getresidual,
    2648                                        pack_progress_params(showprogress,
    2649                                                             minnrow),
    2650                                        outlog, blfile)
     2591            workscan._cspline_baseline(mask, npiece, clipthresh, clipniter, getresidual, pack_progress_params(showprogress, minnrow), outlog, blfile)
    26512592            workscan._add_history("cspline_baseline", varlist)
    26522593           
    … …  
    26602601
    26612602    @asaplog_post_dec
    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):
     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):
    26682606        """\
    26692607        Return a scan which has been baselined (all rows) by cubic spline
    … …  
    26792617            npiece:         Number of pieces. (default is 2)
    26802618            clipthresh:     Clipping threshold. (default is 3.0, unit: sigma)
    2681             clipniter:      maximum number of iteration of 'clipthresh'-sigma
    2682                             clipping (default is 0)
     2619            clipniter:      maximum number of iteration of 'clipthresh'-sigma clipping (default is 0)
    26832620            edge:           an optional number of channel to drop at
    26842621                            the edge of spectrum. If only one value is
    … …  
    27342671                workscan = self.copy()
    27352672           
    2736             if mask           is None: mask           = \
    2737                     [True for i in xrange(workscan.nchan())]
     2673            if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
    27382674            if npiece         is None: npiece         = 2
    27392675            if clipthresh     is None: clipthresh     = 3.0
    … …  
    27492685            if blfile         is None: blfile         = ''
    27502686
    2751             #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is
    2752             # implemented as a fitter method.
     2687            #CURRENTLY, PLOT=true UNAVAILABLE UNTIL cubic spline fitting is implemented as a fitter method.
    27532688            workscan._auto_cspline_baseline(mask, npiece, clipthresh,
    27542689                                            clipniter,
    … …  
    28122747                workscan = self.copy()
    28132748
    2814             if mask         is None: mask         = \
    2815                     [True for i in xrange(workscan.nchan())]
     2749            if mask         is None: mask         = [True for i in \
     2750                                                      xrange(workscan.nchan())]
    28162751            if order        is None: order        = 0
    28172752            if plot         is None: plot         = False
    … …  
    29482883                workscan = self.copy()
    29492884
    2950             if mask           is None: mask           = \
    2951                     [True for i in xrange(workscan.nchan())]
     2885            if mask           is None: mask           = [True for i in xrange(workscan.nchan())]
    29522886            if order          is None: order          = 0
    29532887            if edge           is None: edge           = (0, 0)
    … …  
    33613295            s = scantable(self._math._unaryop(self, other, "SUB", False))
    33623296        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
    3363             if isinstance(other[0], list) or isinstance(other[0],
    3364                                                         numpy.ndarray):
     3297            if isinstance(other[0], list) or isinstance(other[0], numpy.ndarray):
    33653298                from asapmath import _array2dOp
    33663299                s = _array2dOp( self.copy(), other, "SUB", False )
    33673300            else:
    3368                 s = scantable( self._math._arrayop( self.copy(), other,
    3369                                                     "SUB", False ) )
     3301                s = scantable( self._math._arrayop( self.copy(), other, "SUB", False ) )
    33703302        else:
    33713303            raise TypeError("Other input is not a scantable or float value")
    … …  
    33853317            s = scantable(self._math._unaryop(self, other, "MUL", False))
    33863318        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
    3387             if isinstance(other[0], list) or isinstance(other[0],
    3388                                                         numpy.ndarray):
     3319            if isinstance(other[0], list) or isinstance(other[0], numpy.ndarray):
    33893320                from asapmath import _array2dOp
    33903321                s = _array2dOp( self.copy(), other, "MUL", False )
    33913322            else:
    3392                 s = scantable( self._math._arrayop( self.copy(), other,
    3393                                                     "MUL", False ) )
     3323                s = scantable( self._math._arrayop( self.copy(), other, "MUL", False ) )
    33943324        else:
    33953325            raise TypeError("Other input is not a scantable or float value")
    … …  
    34123342            s = scantable(self._math._unaryop(self, other, "DIV", False))
    34133343        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
    3414             if isinstance(other[0], list) or isinstance(other[0],
    3415                                                         numpy.ndarray):
     3344            if isinstance(other[0], list) or isinstance(other[0], numpy.ndarray):
    34163345                from asapmath import _array2dOp
    34173346                s = _array2dOp( self.copy(), other, "DIV", False )
    34183347            else:
    3419                 s = scantable( self._math._arrayop( self.copy(), other,
    3420                                                     "DIV", False ) )
     3348                s = scantable( self._math._arrayop( self.copy(), other, "DIV", False ) )
    34213349        else:
    34223350            raise TypeError("Other input is not a scantable or float value")
Note: See TracChangeset for help on using the changeset viewer.