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.