Changeset 710


Ignore:
Timestamp:
11/11/05 10:01:49 (19 years ago)
Author:
mar637
Message:

create_mask now also handles args[0]=list. auto_quotient checks for conformance between # of ons and offs

Location:
trunk/python
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/python/__init__.py

    r706 r710  
    6161    'plotter.colours'     : ['', str],
    6262    'plotter.linestyles'  : ['', str],
    63    
     63    'plotter.decimate'    : [False, _validate_bool],
     64    'plotter.ganged'      : [True, _validate_bool],
     65
    6466    # scantable
    6567    'scantable.save'      : ['ASAP', str],
    … …  
    8789
    8890    # plotting
    89    
     91
    9092    # do we want a GUI or plot to a file
    9193    plotter.gui                : True
    92    
     94
    9395    # default mode for colour stacking
    9496    plotter.stacking           : Pol
    … …  
    9698    # default mode for panelling
    9799    plotter.panelling          : scan
     100
     101    # push panels together, to shar axislabels
     102    plotter.ganged             : True
    98103
    99104    # default colours/linestyles
    … …  
    221226    return False
    222227
     228from asap._asap import LogSink as _asaplog
     229# use null sink if verbose==False
     230#asaplog=_asaplog(rcParams['verbose'])
     231asaplog=_asaplog()
     232global asaplog
    223233from asapfitter import *
    224234from asapreader import reader
     235
    225236from asapmath import *
     237from asap._asap import _math_setlog
     238_math_setlog(asaplog)
     239
    226240from scantable import *
    227241from asaplinefind import *

  • trunk/python/asaplotbase.py

    r705 r710  
    1212from matplotlib.numerix import sqrt
    1313from matplotlib import rc, rcParams
     14from asap import rcParams as asaprcParams
    1415
    1516class asaplotbase:
    … …  
    3435            self.set_panels(rows, cols)
    3536
    36         # Set matplotlib default colour sequence.
    37         self.colormap = ['blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'black', 'purple', 'orange', 'pink']
     37        # Set matplotlib default colour sequence.
     38        self.colormap = "green red black cyan magenta orange blue purple yellow pink".split()
     39       
     40        c = asaprcParams['plotter.colours']
     41        if isinstance(c,str) and len(c) > 0:
     42            self.colormap = c.split()
     43
     44        self.lsalias = {"line":  [1,0],
     45                        "dashdot": [4,2,1,2],
     46                        "dashed" : [4,2,4,2],
     47                        "dotted" : [1,2],
     48                        "dashdotdot": [4,2,1,2,1,2],
     49                        "dashdashdot": [4,2,4,2,1,2]
     50                        }
     51
     52        styles = "line dashed dotted dashdot".split()
     53        c = asaprcParams['plotter.linestyles']
     54        if isinstance(c,str) and len(c) > 0:
     55            styles = c.split()
     56        s = []
     57        for ls in styles:
     58            if self.lsalias.has_key(ls):
     59                s.append(self.lsalias.get(ls))
     60            else:
     61                s.append('-')
     62        self.linestyles = s
     63
    3864        self.color = 0;
     65        self.linestyle = 0;
    3966        self.attributes = {}
    4067        self.loc = 0
    … …  
    5380        self.lines = []
    5481
    55 
    56     def palette(self, color, colormap=None):
     82    def palette(self, color, colormap=None, linestyle=0, linestyles=None):
    5783        if colormap:
    58             self.colormap = colormap
     84            if isinstance(colormap,list):
     85                self.colormap = colormap
     86            elif isinstance(colormap,str):
     87                self.colormap = colormap.split()
    5988        if 0 <= color < len(self.colormap):
    6089            self.color = color
     90        if linestyles:
     91            self.linestyles = []
     92            if isinstance(linestyles,list):
     93                styles = linestyles
     94            elif isinstance(linestyles,str):
     95                styles = linestyles.split()
     96            for ls in styles:
     97                if self.lsalias.has_key(ls):
     98                    self.linestyles.append(self.lsalias.get(ls))
     99                else:
     100                    self.linestyles.append(self.lsalias.get('line'))
     101        if 0 <= linestyle < len(self.linestyles):
     102            self.linestyle = linestyle
    61103
    62104    def delete(self, numbers=None):
    … …  
    205247            for segment in self.lines[i]:
    206248                getattr(segment, "set_color")(self.colormap[self.color])
    207 
     249                if len(self.colormap)  == 1:
     250                    getattr(segment, "set_dashes")(self.linestyles[self.linestyle])
    208251            self.color += 1
    209252            if self.color >= len(self.colormap):
    210253                self.color = 0
     254
     255            if len(self.colormap) == 1:
     256                self.linestyle += 1
     257            if self.linestyle >= len(self.linestyles):
     258                self.linestyle = 0               
    211259
    212260        self.show()

  • trunk/python/asapmath.py

    r665 r710  
    9494    s._add_history("simple_math", varlist)
    9595    return s
     96   
     97   

  • trunk/python/asapplotter.py

    r709 r710  
    1212    """
    1313    def __init__(self, visible=True):
    14        
    15         if visible:
    16             from asap.asaplotgui import asaplotgui as asaplot
    17         else:
    18             from asap.asaplot import asaplot
    19         self._plotter = asaplot()
    20            
     14
     15        self._visible = visible
     16        self._plotter = self._newplotter()
     17
    2118        self._tdict = {'Time':'t','time':'t','t':'t','T':'t'}
    2219        self._bdict = {'Beam':'b','beam':'b','b':'b','B':'b'}
    … …  
    4542        self._minmaxx = None
    4643        self._minmaxy = None
    47         self._datamask = None
     44        self._datamask = None
    4845        self._data = None
    4946        self._lmap = None
    … …  
    5552                        'i':None, 'p':None
    5653                        }
     54        self._usermask = None
     55        self._usermaskspectra = None
     56
     57    def _newplotter(self):
     58        if self._visible:
     59            from asap.asaplotgui import asaplotgui as asaplot
     60        else:
     61            from asap.asaplot import asaplot
     62        return asaplot()
     63
    5764
    5865    def _translate(self, name):
    … …  
    7380            are consistent e.g. all 'channel' or all 'velocity' etc.
    7481        """
    75         if self._plotter.is_dead:
    76             self._plotter = ASAPlot()
     82        if self._plotter.is_dead:
     83            self._plotter = self._newplotter()
    7784        self._plotter.hold()
    7885        self._plotter.clear()
    … …  
    8188                if list(args) != self._data:
    8289                    self._data = list(args)
    83                     # reset cursor
    84                     self.set_cursor(refresh=False)
     90                    # reset
     91                    self._reset()
    8592            else:
    86                 self._data = list(args)
    87                 self.set_cursor(refresh=False)
     93                if isinstance(args[0], list):
     94                    self._data = args[0]
     95                else:
     96                    self._data = list(args)
     97                self._reset()
    8898        # ranges become invalid when unit changes
    8999        if self._abcunit != self._data[0].get_unit():
    … …  
    91101            self._minmaxy = None
    92102            self._abcunit = self._data[0].get_unit()
    93             self._datamask = None
     103            self._datamask = None
    94104        if self._panelling == 't':
    95105            maxrows = 25
    … …  
    125135            ncol = eval(self._cdict.get(colmode))
    126136        if n > 1:
     137            ganged = rcParams['plotter.ganged']
    127138            if self._rows and self._cols:
    128139                n = min(n,self._rows*self._cols)
    129140                self._plotter.set_panels(rows=self._rows,cols=self._cols,
    130                                          nplots=n)
     141                                         nplots=n,ganged=ganged)
    131142            else:
    132                 self._plotter.set_panels(rows=n,cols=0,nplots=n)
     143                self._plotter.set_panels(rows=n,cols=0,nplots=n,ganged=ganged)
    133144        else:
    134145            self._plotter.set_panels()
    … …  
    171182                if self._abcissa: xlab = self._abcissa
    172183                y = None
     184                m = scan._getmask(rowsel)
     185                if self._usermask and self._usermask.count(j):
     186                    m  = logical_and(self._usermask, m)
    173187                if polmode == "stokes":
    174188                    y = scan._getstokesspectrum(rowsel)
    … …  
    184198                    ylab = scan._get_ordinate_label()
    185199                m = scan._getmask(rowsel)
    186                 if self._datamask is not None:
    187                     if len(m) == len(self._datamask):
    188                         m = logical_and(m,self._datamask)
     200                if self._datamask is not None:
     201                    if len(m) == len(self._datamask):
     202                        m = logical_and(m,self._datamask)
    189203                if self._lmap and len(self._lmap) > 0:
    190204                    llab = self._lmap[jj]
    … …  
    200214                    y = y[s:e]
    201215                    m = m[s:e]
     216                if len(x) > 1024 and rcParams['plotter.decimate']:
     217                    fac = len(x)/1024
     218                    x = x[::fac]
     219                    m = m[::fac]
     220                    y = y[::fac]
    202221                self._plotter.plot(x,y,m)
    203222                xlim=[min(x),max(x)]
    204223                if self._minmaxx is not None:
    205                     xlim = self._minmaxx
    206                 self._plotter.axes.set_xlim(xlim)
     224                    xlim = self._minmaxx
     225                self._plotter.axes.set_xlim(xlim)
    207226            self._plotter.set_axes('xlabel',xlab)
    208227            self._plotter.set_axes('ylabel',ylab)
    … …  
    211230
    212231    def _plot_scans(self, scans, colmode):
    213         print "Can only plot one row per scan."
     232        print "Plotting mode is scans across panels. Can only plot one row per scan."
    214233        if colmode == 's':
    215234            return
    … …  
    227246            ncol = eval(self._cdict.get(colmode))
    228247        if n > 1:
     248            ganged = rcParams['plotter.ganged']
    229249            if self._rows and self._cols:
    230250                n = min(n,self._rows*self._cols)
    231251                self._plotter.set_panels(rows=self._rows,cols=self._cols,
    232                                          nplots=n)
     252                                         nplots=n,ganged=ganged)
    233253            else:
    234                 self._plotter.set_panels(rows=n,cols=0,nplots=n)
     254                self._plotter.set_panels(rows=n,cols=0,nplots=n,ganged=ganged)
    235255        else:
    236256            self._plotter.set_panels()
    … …  
    280300                    ylab = scan._get_ordinate_label()
    281301                m = scan._getmask(rowsel)
    282                 if self._datamask is not None:
    283                     if len(m) == len(self._datamask):
    284                         m = logical_and(m,self._datamask)
     302                if self._usermask and self._usermask.count(j):
     303                    m  = logical_and(self._usermask, m)
    285304                if self._lmap and len(self._lmap) > 0:
    286305                    llab = self._lmap[jj]
    … …  
    296315                    y = y[s:e]
    297316                    m = m[s:e]
    298 
     317                if len(x) > 1024 and rcParams['plotter.decimate']:
     318                    fac = len(x)/1024
     319                    x = x[::fac]
     320                    m = m[::fac]
     321                    y = y[::fac]
    299322                self._plotter.plot(x,y,m)
    300323                xlim=[min(x),max(x)]
    301324                if self._minmaxx is not None:
    302                     xlim = self._minmaxx
     325                    xlim = self._minmaxx
    303326                self._plotter.axes.set_xlim(xlim)
    304327
    … …  
    325348            ncol = eval(self._cdict.get(colmode))
    326349        if n > 1:
     350            ganged = rcParams['plotter.ganged']
    327351            if self._rows and self._cols:
    328352                n = min(n,self._rows*self._cols)
    329353                self._plotter.set_panels(rows=self._rows,cols=self._cols,
    330                                          nplots=n)
     354                                         nplots=n,ganged=ganged)
    331355            else:
    332                 self._plotter.set_panels(rows=n,cols=0,nplots=n)
     356                self._plotter.set_panels(rows=n,cols=0,nplots=n,ganged=ganged)
    333357        else:
    334358            self._plotter.set_panels()
    … …  
    390414                    ylab = scan._get_ordinate_label()
    391415                m = scan._getmask(rowsel)
    392                 if self._datamask is not None:
    393                     if len(m) == len(self._datamask):
    394                         m = logical_and(m,self._datamask)
     416                if self._usermask and self._usermask.count(j):
     417                    m  = logical_and(self._usermask, m)
     418
    395419                if colmode == 's' or colmode == 't':
    396420                    if self._title and len(self._title) > 0:
    … …  
    426450                    y = y[s:e]
    427451                    m = m[s:e]
    428 
     452                if len(x) > 1024 and rcParams['plotter.decimate']:
     453                    fac = len(x)/1024
     454                    x = x[::fac]
     455                    m = m[::fac]
     456                    y = y[::fac]
    429457                self._plotter.plot(x,y,m)
    430458                xlim=[min(x),max(x)]
    431459                if self._minmaxx is not None:
    432                     xlim = self._minmaxx
     460                    xlim = self._minmaxx
    433461                self._plotter.axes.set_xlim(xlim)
    434462
    … …  
    445473        Parameters:
    446474            stacking:     tell the plotter which variable to plot
    447                           as line colour overlays (default 'pol')
     475                          as line color overlays (default 'pol')
    448476            panelling:    tell the plotter which variable to plot
    449477                          across multiple panels (default 'scan'
    … …  
    531559             mp:    a list of 'strings'. This should have the same length
    532560                    as the number of elements on the legend and then maps
    533                     to the indeces in order
     561                    to the indeces in order. It is possible to uses latex
     562                    math expression. These have to be enclosed in r'', e.g. r'$x^{2}$'
    534563
    535564        Example:
    … …  
    537566             for CO and SiO:
    538567             plotter.set_stacking('i')
    539              plotter.set_legend_map(['CO','SiO'])
     568             plotter.set_legend(['CO','SiO'])
    540569             plotter.plot()
     570             plotter.set_legend([r'$^{12}CO$', r'SiO'])
    541571        """
    542572        self._lmap = mp
    … …  
    545575
    546576    def set_title(self, title=None):
     577        """
     578        Set the title of the plot. If multiple panels are plotted,
     579        multiple titles have to be specified.
     580        Example:
     581             # two panels are visible on the plotter
     582             plotter.set_title(["First Panel","Second Panel"])
     583        """
    547584        self._title = title
    548585        if self._data: self.plot()
    … …  
    550587
    551588    def set_ordinate(self, ordinate=None):
     589        """
     590        Set the y-axis label of the plot. If multiple panels are plotted,
     591        multiple labels have to be specified.
     592        Example:
     593             # two panels are visible on the plotter
     594             plotter.set_ordinate(["First Y-Axis","Second Y-Axis"])
     595        """
    552596        self._ordinate = ordinate
    553597        if self._data: self.plot()
    … …  
    555599
    556600    def set_abcissa(self, abcissa=None):
     601        """
     602        Set the x-axis label of the plot. If multiple panels are plotted,
     603        multiple labels have to be specified.
     604        Example:
     605             # two panels are visible on the plotter
     606             plotter.set_ordinate(["First X-Axis","Second X-Axis"])
     607        """
    557608        self._abcissa = abcissa
    558609        if self._data: self.plot()
    559610        return
    560611
    561     def save(self, filename=None, orientation=None,dpi=None):
     612    def set_colors(self, colormap):
     613        """
     614        Set the colors to be used. The plotter will cycle through
     615        these colors when lines are overlaid (stacking mode).
     616        Example:
     617             plotter.set_colors("red green blue")
     618             # If for example four lines are overlaid e.g I Q U V
     619             # 'I' will be 'red', 'Q' will be 'green', U will be 'blue'
     620             # and 'V' will be 'red' again.
     621        """
     622        if isinstance(colormap,str):
     623            colormap = colormap.split()
     624        self._plotter.palette(0,colormap=colormap)
     625        if self._data: self.plot()
     626
     627    def set_linestyles(self, linestyles):
     628        """
     629        Parameters:
     630             linestyles:     a list of linestyles to use.
     631                             'line', 'dashed', 'dotted', 'dashdot',
     632                             'dashdotdot' and 'dashdashdot' are
     633                             possible
     634
     635        Set the linestyles to be used. The plotter will cycle through
     636        these linestyles when lines are overlaid (stacking mode) AND
     637        only one color has been set.
     638        Example:
     639             plotter.set_colors("black")
     640             plotter.set_linestyles("line dashed dotted dashdot")
     641             # If for example four lines are overlaid e.g I Q U V
     642             # 'I' will be 'solid', 'Q' will be 'dashed',
     643             # U will be 'dotted' and 'V' will be 'dashdot'.
     644        """
     645        if isinstance(linestyles,str):
     646            linestyles = linestyles.split()
     647        self._plotter.palette(color=0,linestyle=0,linestyles=linestyles)
     648        if self._data: self.plot()
     649
     650    def save(self, filename=None, orientation=None, dpi=None):
    562651        """
    563652        Save the plot to a file. The know formats are 'png', 'ps', 'eps'.
    … …  
    572661                          If None is choosen for 'ps' output, the plot is
    573662                          automatically oriented to fill the page.
     663             dpi:         The dpi of the output non-ps plot
    574664        """
    575665        self._plotter.save(filename,orientation,dpi)
    … …  
    640730        dstokes2 = {"I":0,"Plinear":1,"Pangle":2,"V":3}
    641731        draw = {"XX":0, "YY":1,"Real(XY)":2, "Imag(XY)":3}
    642         dcirc = { "RR":0,"LL":1}#,"Real(RL)":2,"Image(RL)":3}
     732        dcirc = { "RR":0,"LL":1}#,"Real(RL)":2,"Imag(RL)":3}
    643733
    644734        if pol is None:
    … …  
    677767        if self._data and refresh: self.plot()
    678768
     769    def set_mask(self, mask=None, pol=None):
     770        if not self._data:
     771            print "Can only set cursor after a first call to plot()"
     772            return
     773        if isinstance(mask, array):
     774            self._usermask = mask
     775        if isinstance(mask, list):
     776            self._usermask = array(mask)
     777        if mask is None and pol is None:
     778            self._usermask = None
     779            self._usermaskspectra = None
     780
     781        dstokes = {"I":0,"Q":1,"U":2,"V":3}
     782        dstokes2 = {"I":0,"Plinear":1,"Pangle":2,"V":3}
     783        draw = {"XX":0, "YY":1,"Real(XY)":2, "Imag(XY)":3}
     784        dcirc = { "RR":0,"LL":1}#,"Real(RL)":2,"Imag(RL)":3}
     785        if isinstance(pol, str):
     786            pol = pol.split()
     787        if isinstance(pol, list):
     788            if isinstance(pol[0], str):
     789                pass
     790            else:
     791                cpos = self._cursor[self._stacking]
     792                self._usermaskspectra =filter(lambda i: filter(lambda j: j==i ,cpos),pol)
     793        else:
     794            return
     795        self.plot()
     796
    679797    def _get_pollabel(self, scan, polmode):
    680798        tlab = ""
    … …  
    711829        return start,end
    712830
    713 #if __name__ == '__main__':
    714 #    plotter = asapplotter()
     831    def _reset(self):
     832        self._usermask = None
     833        self._usermaskspectra = None
     834        self.set_cursor(refresh=False)

  • trunk/python/scantable.py

    r670 r710  
    88        The ASAP container for scans
    99    """
    10    
     10
    1111    def __init__(self, filename, average=None, unit=None):
    1212        """
    … …  
    2727                         (input rpfits/sdfits/ms) or replaces the value
    2828                         in existing scantables
    29         """       
     29        """
    3030        if average is None or type(average) is not bool:
    31             average = rcParams['scantable.autoaverage']           
     31            average = rcParams['scantable.autoaverage']
    3232
    3333        varlist = vars()
    3434        self._vb = rcParams['verbose']
    3535        self._p = None
    36 
     36        from asap import asaplog
    3737        if isinstance(filename,sdtable):
    38             sdtable.__init__(self, filename)           
     38            sdtable.__init__(self, filename)
    3939            if unit is not None:
    40                 self.set_fluxunit(unit)                       
     40                self.set_fluxunit(unit)
    4141        else:
    4242            import os.path
    4343            if not os.path.exists(filename):
    44                 print "File '%s' not found." % (filename)
    45                 return
     44                s = "File '%s' not found." % (filename)
     45                if rcParams['verbose']:
     46                    asaplog.push(s)
     47                    print asaplog.pop().strip()
     48                    return
     49                raise IOError(s)
    4650            filename = os.path.expandvars(filename)
    4751            if os.path.isdir(filename):
    … …  
    5054                    sdtable.__init__(self, filename)
    5155                    if unit is not None:
    52                         self.set_fluxunit(unit)                       
     56                        self.set_fluxunit(unit)
    5357                else:
    5458                    print "The given file '%s'is not a valid asap table." % (filename)
    5559                    return
    56             else:           
     60            else:
    5761                from asap._asap import sdreader
    5862                ifSel = -1
    5963                beamSel = -1
    60                 r = sdreader(filename,ifSel,beamSel)
    61                 print 'Importing data...'
     64                r = sdreader()
     65                r._setlog(asaplog)
     66                r._open(filename,ifSel,beamSel)
     67                asaplog.push('Importing data...')
    6268                r._read([-1])
    6369                tbl = r._getdata()
    … …  
    6672                if average:
    6773                    from asap._asap import average as _av
    68                     print 'Auto averaging integrations...'
     74                    asaplog.push('Auto averaging integrations...')
    6975                    tbl2 = _av((tbl,),(),True,'none')
    7076                    sdtable.__init__(self,tbl2)
    … …  
    7480                del r,tbl
    7581                self._add_history("scantable", varlist)
     82                log = asaplog.pop()
     83                if len(log): print log
    7684
    7785    def save(self, name=None, format=None, stokes=False, overwrite=False):
    7886        """
    79         Store the scantable on disk. This can be an asap (aips++) Table, SDFITS, 
     87        Store the scantable on disk. This can be an asap (aips++) Table, SDFITS,
    8088        Image FITS or MS2 format.
    8189        Parameters:
    … …  
    8896                         Allowed are - 'ASAP' (save as ASAP [aips++] Table),
    8997                                       'SDFITS' (save as SDFITS file)
    90                                        'FITS' (saves each row as a FITS Image) 
     98                                       'FITS' (saves each row as a FITS Image)
    9199                                       'ASCII' (saves as ascii text file)
    92100                                       'MS2' (saves as an aips++
    … …  
    192200                print "Illegal file name '%s'." % (filename)
    193201        print info
    194            
     202
    195203    def set_cursor(self, beam=0, IF=0, pol=0):
    196204        """
    … …  
    370378            retval = {'axes': axes, 'data': array(statval), 'cursor':(i,j,k)}
    371379            return retval
    372        
     380
    373381    def get_time(self, row=-1):
    374382        """
    … …  
    409417        Set the instrument for subsequent processing
    410418        Parameters:
    411             instr:    Select from 'ATPKSMB', 'ATPKSHOH', 'ATMOPRA', 
     419            instr:    Select from 'ATPKSMB', 'ATPKSHOH', 'ATMOPRA',
    412420                      'DSS-43' (Tid), 'CEDUNA', and 'HOBART'
    413421        """
    … …  
    427435        if self._p: self.plot()
    428436        self._add_history("set_doppler",vars())
    429  
     437
    430438    def set_freqframe(self, frame=None):
    431439        """
    … …  
    450458        else:
    451459            print "Please specify a valid freq type. Valid types are:\n",valid
    452            
     460
    453461    def get_unit(self):
    454462        """
    … …  
    474482        """
    475483        abc = self._getabcissa(rowno)
    476         lbl = self._getabcissalabel(rowno)       
     484        lbl = self._getabcissalabel(rowno)
    477485        return abc, lbl
    478486        #return {'abcissa':abc,'label':lbl}
    … …  
    505513            # masks the regions between 400 and 500
    506514            # and 800 and 900 in the unit 'channel'
    507            
     515
    508516        """
    509517        row = 0
    … …  
    517525        n = self.nchan()
    518526        msk = zeros(n)
    519         for window in args:
     527        # test if args is a 'list' or a 'normal *args - UGLY!!!
     528
     529        ws = (isinstance(args[-1][-1],int) or isinstance(args[-1][-1],float)) and args or args[0]
     530        print ws
     531        for window in ws:
     532            print window
    520533            if (len(window) != 2 or window[0] > window[1] ):
    521534                print "A window needs to be defined as [min,max]"
    … …  
    527540            if kwargs.get('invert'):
    528541                from numarray import logical_not
    529                 msk = logical_not(msk)           
     542                msk = logical_not(msk)
    530543        return msk
    531    
     544
    532545    def get_restfreqs(self):
    533546        """
    … …  
    558571        a vector, then it MUST be of length the number of IFs
    559572        (and the available restfrequencies will be replaced by
    560         this vector).  In this case, *all* data ('source' and 
    561         'theif' are ignored) have the restfrequency set per IF according 
    562         to the corresponding value you give in the 'freqs' vector. 
    563         E.g. 'freqs=[1e9,2e9]'  would mean IF 0 gets restfreq 1e9 and 
     573        this vector).  In this case, *all* data ('source' and
     574        'theif' are ignored) have the restfrequency set per IF according
     575        to the corresponding value you give in the 'freqs' vector.
     576        E.g. 'freqs=[1e9,2e9]'  would mean IF 0 gets restfreq 1e9 and
    564577        IF 1 gets restfreq 2e9.
    565578
    … …  
    596609        sdtable._setrestfreqs(self, freqs, unit, lines, source, theif)
    597610        self._add_history("set_restfreqs", varlist)
    598        
     611
    599612
    600613
    … …  
    633646        """
    634647        print "Warning! Not fully functional. Use plotter.plot() instead"
    635        
     648
    636649        validcol = {'Beam':self.nbeam(),'IF':self.nif(),'Pol':self.npol()}
    637650
    … …  
    659672        xlab,ylab,tlab = None,None,None
    660673        self._vb = False
    661         sel = self.get_cursor()       
     674        sel = self.get_cursor()
    662675        for i in range(npan):
    663676            if npan > 1:
    … …  
    700713        return
    701714
    702         print out 
     715        print out
    703716
    704717    def _print_values(self, dat, label='', timestamps=[]):
    … …  
    722735        print " ", label
    723736        print "-"*80
    724         print out 
     737        print out
    725738
    726739    def history(self):
    … …  
    735748                func = items[1]
    736749                items = items[2:]
    737                 print date           
     750                print date
    738751                print "Function: %s\n  Parameters:" % (func)
    739752                for i in items:
    … …  
    765778        Example:
    766779            # time average the scantable without using a mask
    767             newscan = scan.average_time()           
     780            newscan = scan.average_time()
    768781        """
    769782        varlist = vars()
    770783        if weight is None: weight = 'tint'
    771784        if mask is None: mask = ()
    772         from asap._asap import average as _av       
     785        from asap._asap import average as _av
    773786        s = scantable(_av((self,), mask, scanav, weight))
    774787        s._add_history("average_time",varlist)
    775788        return s
    776        
     789
    777790    def convert_flux(self, jyperk=None, eta=None, d=None, insitu=None,
    778791                     allaxes=None):
    … …  
    873886            self._add_history("gain_el", varlist)
    874887            return
    875    
     888
    876889    def freq_align(self, reftime=None, method='cubic', perif=False,
    877890                   insitu=None):
    … …  
    957970            return
    958971
    959    
     972
    960973    def resample(self, width=5, method='cubic', insitu=None):
    961974        """
    … …  
    11111124        from asap.asaplinefind import linefinder
    11121125        from asap import _is_sequence_or_number as _is_valid
    1113        
     1126
    11141127        if not _is_valid(edge, int):
    11151128            raise RuntimeError, "Parameter 'edge' has to be an integer or a \
    11161129            pair of integers specified as a tuple"
    1117        
     1130
    11181131        # setup fitter
    11191132        f = fitter()
    … …  
    11611174    def rotate_linpolphase(self, angle, allaxes=None):
    11621175        """
    1163         Rotate the phase of the complex polarization O=Q+iU correlation. 
    1164         This is always done in situ in the raw data.  So if you call this 
     1176        Rotate the phase of the complex polarization O=Q+iU correlation.
     1177        This is always done in situ in the raw data.  So if you call this
    11651178        function more than once then each call rotates the phase further.
    11661179        Parameters:
    … …  
    11781191        self._add_history("rotate_linpolphase", varlist)
    11791192        return
    1180    
     1193
    11811194
    11821195    def rotate_xyphase(self, angle, allaxes=None):
    … …  
    12661279                            trailing '_R' (Mopra/Parkes) or
    12671280                            '_e'/'_w' (Tid)
    1268             preserve:       you can preserve (default) the continuum or 
    1269                             remove it.  The equations used are 
     1281            preserve:       you can preserve (default) the continuum or
     1282                            remove it.  The equations used are
    12701283                            preserve: Output = Toff * (on/off) - Toff
    12711284                            remove:   Output = Tref * (on/off) - Ton
    … …  
    12801293            srcs = self.get_scan("*[^_ewR]")
    12811294            refs = self.get_scan("*[_ewR]")
    1282             return scantable(_quot(srcs,refs, preserve))       
     1295            if isinstance(srcs,scantable) and isinstance(refs,scantable):
     1296                ns,nr = srcs.nrow(),refs.nrow()
     1297                if nr > ns:
     1298                    refs = refs.get_scan(range(ns))
     1299                return scantable(_quot(srcs,refs, preserve))
     1300            else:
     1301                raise RuntimeError("Couldn't find any on/off pairs")
    12831302        else:
    12841303            print "not yet implemented"
    12851304            return None
    1286        
     1305
    12871306    def quotient(self, other, isreference=True, preserve=True):
    12881307        """
    … …  
    12961315            isreference:    if the 'other' scan is the reference (default)
    12971316                            or source
    1298             preserve:       you can preserve (default) the continuum or 
    1299                             remove it.  The equations used are 
     1317            preserve:       you can preserve (default) the continuum or
     1318                            remove it.  The equations used are
    13001319                            preserve: Output = Toff * (on/off) - Toff
    13011320                            remove:   Output = Tref * (on/off) - Ton
    … …  
    13161335        s = None
    13171336        if isinstance(other, scantable):
    1318             from asap._asap import b_operate as _bop           
     1337            from asap._asap import b_operate as _bop
    13191338            s = scantable(_bop(self, other, 'add', True))
    13201339        elif isinstance(other, float):
    … …  
    13351354        s = None
    13361355        if isinstance(other, scantable):
    1337             from asap._asap import b_operate as _bop           
     1356            from asap._asap import b_operate as _bop
    13381357            s = scantable(_bop(self, other, 'sub', True))
    13391358        elif isinstance(other, float):
    … …  
    13451364        s._add_history("operator -", varlist)
    13461365        return s
    1347    
     1366
    13481367    def __mul__(self, other):
    13491368        """
    … …  
    13531372        s = None
    13541373        if isinstance(other, scantable):
    1355             from asap._asap import b_operate as _bop           
     1374            from asap._asap import b_operate as _bop
    13561375            s = scantable(_bop(self, other, 'mul', True))
    13571376        elif isinstance(other, float):
    … …  
    13661385        s._add_history("operator *", varlist)
    13671386        return s
    1368    
     1387
    13691388
    13701389    def __div__(self, other):
    … …  
    13751394        s = None
    13761395        if isinstance(other, scantable):
    1377             from asap._asap import b_operate as _bop           
     1396            from asap._asap import b_operate as _bop
    13781397            s = scantable(_bop(self, other, 'div', True))
    13791398        elif isinstance(other, float):
    … …  
    14421461        hist = hist[:-2] # remove trailing '##'
    14431462        self._addhistory(hist)
    1444        
     1463
    14451464
    14461465    def _zip_mask(self, mask):
    … …  
    14531472                j = i + mask[i:].index(0)
    14541473            else:
    1455                 j = len(mask)               
     1474                j = len(mask)
    14561475            segments.append([i,j])
    1457             i = j       
     1476            i = j
    14581477        return segments
    14591478    def _get_ordinate_label(self):
    … …  
    14661485            lbl = "Flux density "+ fu
    14671486        return lbl
    1468        
     1487
Note: See TracChangeset for help on using the changeset viewer.